day05-java-（循环问题，数组）

　　　　　　day05-java-（循环问题，数组）　　　　

1.三种循环结构的更佳适用情况:
  1)while: "当..."循环
  2)do...while: "直到..."循环
                要素1与要素3相同时首选
  3)for:固定次数循环

循环结构的选择:
1.先看固定次数还是不固定次数:
    固定次数-----首选for
    不固定次数-----再看要素1与3是否相同
        要素1与要素3相同时-----首选do...while
        要素1与要素3不同时-----首选while

2.嵌套循环:
  1)循环中套循环，一般多行多列时使用，外层控制行，内层控制列
  2)执行过程:外层循环走一次，内层循环走所有次
  3)建议:循环层数越少越好，能用一层就不用两层，能用两层就不用三层
         若需求必须要通过三层以上循环才能解决，说明设计有问题
  4)break只能跳出一层循环

3.程序=算法+数据结构
  1)算法:解决问题的流程/步骤(顺序、分支、循环)
  2)数据结构:将数据按照某种特定的结构来保存
             数怎么存
    设计良好的数据结构会导致好的算法

4.数组:
  1)相同数据类型元素的集合
  2)数组是一种数据类型(引用类型)
  3)数组的定义:
      int[] arr = new int[4];
  4)数组的初始化:
      int[] arr = new int[4]; //0,0,0,0
      int[] arr = {1,3,5,7};  //1,3,5,7
      int[] arr = new int[]{1,3,5,7}; //1,3,5,7
      int[] arr;
      arr = {1,3,5,7}; //编译错误
      arr = new int[]{1,3,5,7}; //正确
      
    //声明浮点型数组d，包含8个元素
    //每个元素都是double型，默认值为0.0
    double[] d = new double[8];

    //声明布尔型数组b，包含26个元素
    //每个元素都是boolean型，默认值为false
    boolean[] b = new boolean[26];

    //声明整型数组a，包含4个元素
    //每个元素都是int类型，默认值为0
    int[] a = new int[4]; //0,0,0,0
    
  5)数组的访问:
    5.1)通过(数组名.length)可以获取数组的长度
          int[] arr = new int[4];
          System.out.println(arr.length); //4
    5.2)通过下标/索引来访问数组中的元素
        下标从0开始，最大到(数组的长度-1)
          int[] arr = new int[3];
          arr[0] = 100; //给arr中第1个元素赋值为100
          arr[1] = 200; //给arr中第2个元素赋值为200
          arr[2] = 300; //给arr中第3个元素赋值为300
          arr[3] = 400; //数组下标越界异常
          System.out.println(arr[arr.length-1]); //输出最后一个元素的值

  6)数组的遍历:
      int[] arr = new int[10];
      for(int i=0;i<arr.length;i++){
        arr[i] = 100;
      }
      for(int i=0;i<arr.length;i++){
        System.out.println(arr[i]);
      }
      for(int i=arr.length-1;i>=0;i--){
        System.out.println(arr[i]);
      }

  7)数组的复制:
    7.1)System.arraycopy(a,1,a1,0,4);
    7.2)int[] a1 = Arrays.copyOf(a,6);
        a = Arrays.copyOf(a,a.length+1); //扩容
        a = Arrays.copyOf(a,a.length-1); //缩容

  8)数组的排序:
    8.1)Arrays.sort(arr); //升序
    8.2)冒泡原理:
        8.2.1)四个数冒3轮
        8.2.2)每一轮都是从第1个元素开始冒
              每一次都和它的下一个元素比
        8.2.3)冒出来的就不带它玩了

   9)计算程序执行时间：
    long a = System.currentTimeMillis();
    Arrays.sort(arr);
    long b = System.currentTimeMillis();

    System.out.println(b-a); //排序消耗的毫秒数

冒泡排序执行过程：
int[] arr = {45,8,34,1}; //升序
第一轮:
  45和8比，换，8,45,34,1
  45和34比，换，8,34,45,1
  45和1比，换，8,34,1,45-------45冒出来了
第二轮:
  8和34比，不换
  34和1比，换，8,1,34,45-------34冒出来了
第三轮:
  8和1比，换，1,8,34,45--------8冒出来了

找最大值算法:

int[] arr = {23,45,67,10};
1)假设第1个元素最大
    int max = arr[0];
2)遍历剩余元素，将剩余元素与max对比，
  若剩余元素大于max，则修改max的值为较大的
    for(int i=1;i<arr.length;i++){
      if(arr[i]>max){
        max = arr[i];
      }
    }
max=23/45/67

数组操作代码演示：

package day05;
import java.util.Arrays;

//数组的演示
public class ArrayDemo {
    public static void main(String[] args) {
        //6.数组的排序
        int[] arr = {23,56,4,57,24,1,7,9};
        Arrays.sort(arr); //对arr升序
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        
        /*
        //5.数组的复制
        int[] a = {10,20,30,40,50};
        //数组的扩容(创建一个新的数组)
        a = Arrays.copyOf(a,a.length+1);
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
        */
        /*
        int[] a = {10,20,30,40,50};
        //a:源数组
        //a1:目标数组
        //6:目标数组的长度
        int[] a1 = Arrays.copyOf(a,4);
        for(int i=0;i<a1.length;i++){
            System.out.println(a1[i]);
        }
        */
        /*
        int[] a = {10,20,30,40,50};
        int[] a1 = new int[6];
        //a:源数组
        //1:源数组的起始下标
        //a1:目标数组
        //0:目标数组的起始下标
        //4:复制的元素个数
        System.arraycopy(a,1,a1,0,4);
        for(int i=0;i<a1.length;i++){
            System.out.println(a1[i]);
        }
        */
        
        
        /*
        //4.数组的遍历
        int[] arr = new int[10];
        for(int i=0;i<arr.length;i++){
            arr[i] = (int)(Math.random()*100); 
        }
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        */
        
        /*
        //3.数组的访问
        int[] arr = new int[3];
        System.out.println(arr.length); //3.
        arr[0] = 100; //给arr中第1个元素赋值为100
        arr[1] = 200;
        arr[2] = 300;
        //arr[3] = 400; //数组下标越界异常
        System.out.println(arr[arr.length-1]); //300
        */
        
        /*
        //2.数组的初始化
        int[] arr = new int[4]; //0,0,0,0
        int[] arr1 = {1,4,6,8}; //1,4,6,8
        int[] arr2 = new int[]{1,4,6,8}; //1,4,6,8
        int[] arr3;
        //arr3 = {1,4,6,8}; //编译错误
        arr3 = new int[]{1,4,6,8}; //正确
        */
        
        /*
        //1.数组的定义
        //声明整型数组arr，包含10个元素，每个元素都是int类型，默认值为0
        int[] arr = new int[10];
        */
    }
}

 求数组元素的最大值

package day05;
import java.util.Arrays;
//求数组元素的最大值
public class MaxOfArray {
    public static void main(String[] args) {
        //给arr赋值
        int[] arr = new int[10];
        for(int i=0;i<arr.length;i++){
            arr[i] = (int)(Math.random()*100);
            System.out.println(arr[i]);
        }
        
        //找arr中的最大值
        int max = arr[0]; //假设第1个元素最大
        for(int i=1;i<arr.length;i++){ //遍历剩余元素
            if(arr[i]>max){ //若剩余元素大于max
                max=arr[i]; //修改max的值为较大的
            }
        }
        System.out.println("最大值为:"+max);
        
        //扩容
        arr = Arrays.copyOf(arr,arr.length+1);
        //将最大值赋值给arr中的最后一个元素
        arr[arr.length-1] = max;
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        
    }
}

九九乘法表

package day05;
//九九乘法表
public class MultiTable {
    public static void main(String[] args) {
        for(int num=1;num<=9;num++){ //控制行
            for(int i=1;i<=num;i++){ //控制列
                System.out.print(i+"*"+num+"="+i*num+"	");
            }
            System.out.println(); //换行
        }
        /*
         * num=4
         *   ......
         * num=3
         *   i=1 1*3=3
         *   i=2 2*3=6
         *   i=3 3*3=9
         *   i=4
         *   换行
         * num=2
         *   i=1 1*2=2
         *   i=2 2*2=4
         *   i=3
         *   换行
         * num=1
         *   i=1 1*1=1
         *   i=2
         *   换行
         */
        
    }
}

冒泡排序算法

package day05;
//冒泡排序算法
public class BubbleSort {
    public static void main(String[] args) {
        /*
         * 要求:
         * 1.声明整型数组arr包含10个元素，
         *   每个元素为0到99之间的随机数，
         *   输出每个元素的值
         * 2.冒泡方式对arr进行升序排列
         * 3.输出arr排序后的数据
         */
        int[] arr = new int[10];
        for(int i=0;i<arr.length;i++){
            arr[i] = (int)(Math.random()*100);
            System.out.println(arr[i]);
        }
        for(int i=0;i<arr.length-1;i++){ //控制轮数
            for(int j=0;j<arr.length-1-i;j++){ //控制次数
                if(arr[j]<arr[j+1]){ //每次都是和它的下一个元素比
                    int t = arr[j]; //满足条件则交换
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                }
                //若前数大于后数则交换，保证前数小于后数(升序)
                //若前数小于后数则交换，保证前数大于后数(降序)
            }
        }
        
        System.out.println("排序后:");
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

 课后作业：

判断一个数字是否是质数：

方法一，判断？是否为质数：
package day06;
public class Test01 {
    public static void main(String[] args) {
        int num = 1;
        boolean flag = true; //1.假设是质数
        //for(int i=2;i<num;i++){ //2/3/4/.../98/99
        //for(int i=2;i<=num/2;i++){ //2/3/4/.../49/50
        for(int i=2;i<=Math.sqrt(num);i++){ //2/3/4/.../9/10
            if(num%i==0){
                flag = false; //2.修改为不是质数
                break;
            }
        }
        if(flag){ //3.判断得结论 相当于if(flag==true){
            System.out.println(num+"是质数");
        }else{
            System.out.println(num+"不是质数");
        }
    }
}

方法二，判断0~100之间的质数：
package day06;
import java.util.Scanner;
public class Test01 {
    public static void main(String[] args) {
        int count = 0; //质数的个数
        for(int num=2;num<=100;num++){
            boolean flag = true;
            for(int i=2;i<=Math.sqrt(num);i++){ //2/3/4/.../9/10
                if(num%i==0){
                    flag = false;
                    break;
                }
            }
            if(flag){
                count++; //质数个数增1
                System.out.print(num+"	");
                if(count%10==0){
                    System.out.println();
                }
            }
        }
    }
}

方法三，判断2~？之间哪些是质数：
package day06;
import java.util.Scanner;
public class Test01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入查找质数的范围：2~");
        int max = scanner.nextInt();
        scanner.close();
        int numOfPrime = 0;
        for (int n = 2; n <= max; n++) {
            // 判断n是否是质数
            int m = (int) Math.sqrt(n);
            int i = 2;
            for (; i <= m; i++) {
                if (n % i == 0)
                    break;
            }
            if (i > m) {
                System.out.print(n + " ");
                if (++numOfPrime % 10 == 0)
                    System.out.println();
            }
        }
        System.out.println("
共有" + numOfPrime + "个质数");
    }
}

求0~99之间的10个随机数，进行排序，并求出最小数为？

方法一：
package day06;
import java.util.Scanner;
public class Test01 {
    public static void main(String[] args) {
        int[] arr = new int[10];
        for(int i=0;i<arr.length;i++){
            arr[i] = (int)(Math.random()*100);
            System.out.println(arr[i]);
        }
        
        int min = arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i]<min){
                min=arr[i];
            }
        }
        System.out.println("最小值为:"+min);
        
        int[] arr1 = new int[arr.length+1];
        System.arraycopy(arr,0,arr1,1,arr.length);
        arr1[0] = min;
        for(int i=0;i<arr1.length;i++){
            System.out.println(arr1[i]);
        }
    }
}

方法二：
package day06;
import java.util.Random;
import java.util.Arrays;
public class Test01 {
    public static void main(String[] args) {
        //创建一个 10 个长度的数组
        int[] arr = new int[10];
        
        //随机生成 10 个0－99之间的数值，放入数组
        Random ran = new Random();
        for(int i=0;i<arr.length;i++){
            arr[i] = ran.nextInt(100);            
        }
        //打印数组中的数据
        System.out.println("数组中的数据为：" + Arrays.toString(arr));
        
        //查询最小值
        int min = arr[0];
        for(int i=1; i<arr.length; i++) {
            if(min > arr[i]) {
                min = arr[i];
            }
        }
        System.out.println("最小值是：" + min);
        
        //创建新数组
        int[] arrNew = new int[arr.length + 1];
        //将原数组的元素拷贝进入新数组
        System.arraycopy(arr, 0, arrNew, 1, arrNew.length-1);
        
        //最小值放入新数组第一位，并打印新数组
        arrNew[0] = min;
        System.out.println("新数组中的数据为：" + Arrays.toString(arrNew));
    }    
}