Day4-循环和数组（P31~38）

循环

循环语句功能：在某些条件满足的情况下，反复执行特定代码的功能

循环语句的四个组成部分

初始化部分（init_statement）
循环条件部分（test_exp）
循环体部分（body_statement）
迭代部分（alter_statement）

循环语句分类: for 循环、while 循环、do/while 循环

for 循环语句

语法格式
for (初始化表达式①; 布尔值测试表达式②; 更改表达式)｛
语句或语句块③；
｝

1. 从1循环到150并在每行打印一个值，另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7 的倍数行上打印输出“baz” 。2. 打印1~100之间所有奇数的和3. 打印1~100之间所有是7的倍数的整数的个数及总和（体会设置计数器的思想）4. 输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。例如： 153 = 111 + 333 + 555

while 循环语句

while( 布尔值测试表达式)｛
语句或语句块; [更改语句;]
}

do-while 循环语句

do｛
语句或语句块; [更改语句;]
｝while(布尔值测试表达式);

~~5. 求1到100之间所有偶数的和。用for和while语句分别完成.~~

嵌套循环

将一个循环放在另一个循环体内，就形成了嵌套循环。其中， for ,while ,do…while均可以作为外层循环和内层循环。
实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n=mn次。

~~例题：1）九九乘法表 2）1—100之间的所有质数~~

break语句用于终止某个语句块的执行
break终止当前所在的循环
continue语句用于跳过某个循环语句块的一次执行
continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环

return：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。与break和continue不同的是，return直接结束整个方法，不管这个 return处于多少层循环之内

数组

一维数组的声明方式： type var[] 或 type[] var

例如：
int a[];
int[] a1;
double b[];
Mydate[] c; //对象数组

动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行

int[] arr = new int[3];
arr[0] = 3;
arr[1] = 9;
arr[2] = 8;

静态初始化：在定义数组的同时就为数组元素分配空间并赋值。
int a[] = new int[]{ 3, 9, 8};
int[] a = {3,9,8};

数组元素的引用

定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
数组元素的引用方式：数组名[数组元素下标]
数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]
每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)
数组一旦初始化，其长度是不可变的

多维数组

二维数组[][]：数组中的数组
int[][] arr = new int[2][3]; //定义了名称为arr的二维数组里有三个一维数组，每一个一维数组中有两个元素。

int[][] arr = new int[][]{{3,4,2},{2,6},{9,0,4,6}}; //第三个一维数组的长度是arr[2].length;

java重点多维数组不必都是规则矩阵形式。
int[]x,y[];是特殊写法，x是一维数组，y是二维数组。

数组中涉及的常见算法

1.求数组元素的最大值、最小值、总和、平均数
2.数组的复制、反转
3.数组元素的排序

数组排序 🚩
插入排序 ➢ 直接插入排序、折半插入排序、Shell排序
交换排序 ➢ 冒泡排序、快速排序（或分区交换排序）
选择排序 ➢ 简单选择排序、堆排序
归并排序
基数排序

冒泡排序排序思想：相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其它的数进行类似操作。

作业
使用简单数组 (1)创建一个名为TestArray的类，在main()方法中声明array1和array2两个变量，他们是 int[]类型的数组。 (2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。 (3)显示array1的内容。 (4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。思考：array1和array2是什么关系？拓展：修改题目，实现array2对array1数组的复制

public class jiujiu {
    public static void main(String[] args){
        //九九乘法表   
            for(int i = 1; i <= 9; i++){
                for(int j = 1; j <=i; j++){
                    System.out.print(i + "*" + j + "=" + (i*j)+"\t");                
                }
                System.out.println();            
            }
        }    
}

public class ZhiShu {
    public static void main(String[] args){
        int cou = 0;
        for(int i = 1; i <= 100; i++){
            int count = 0;
            for(int j = 1; j <= i; j++){
                if(i%j == 0){
                    count++;
                }}
            
        if(count == 2){
            System.out.println(i);
            cou++;
            }    
        } 
      System.out.println("质数的数量是"+cou);    
    }    
}

public static void main(String[] args){
       //输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
       //例如： 153 = 1*1*1 + 3*3*3 + 5*5*5 
       int count =0;
       System.out.print("水仙花数有：");
       for(int i = 100; i <1000; i++){
           //数字x 
           //百位数是x/100
           //十位(x - a*100)/10;
          //个位x%10;
          //水仙花 x=(x/100)*(x/100)*(x/100)+((x - a*100)/10)*((x - a*100)/10)*((x - a*100)/10)+(x%10)*(x%10)*(x%10)          
          int a = i/100;
          int b = (i - a*100)/10;
          int c = i%10;
          
          //System.out.println(a+""+b+c);
          if(i == a*a*a + b*b*b + c*c*c){
              System.out.print(i+" ");
              count++;
          }          
       }
        System.out.println("\n"+"水仙花数的个数是："+count);       
    }

public class Arr2 {
    public static void main(String[] args){
       
        //test();
       // copy();
       // rev();
       //pao();
       TestArray();
    
    }
    public static void test(){
        int[] arr = {4, 2, 7, 1, 3, 5};
        //求数组元素的最大值、最小值、总和、平均数
        int max = arr[0];
        int min = arr[0];
        int sum = 0;
        
        for(int i = 0; i <arr.length; i++){
            if(max < arr[i]){
                max = arr[i];   
            }
            if(min > arr[i]){
                min = arr[i];
            }
            sum += arr[i];
           }
            int avg = sum/(arr.length+1);
         System.out.println(max+" ,"+min+" ,"+sum+" ,"+avg);
    } 
    //复制
    public static void copy(){
        int[] arr = {4, 2, 7, 1, 3, 5};
        int[] copy = new int[arr.length];
        for(int i = 0; i < arr.length; i++){
            copy[i] = arr[i];
        }
        System.out.println(copy[2]);    
    }
    //反转
    public static void rev(){
         int[] arr = {4, 2, 7, 1, 3, 5};
         int[] rev = new int[arr.length];
         int j = 0;
         for(int i = arr.length - 1; i >= 0; i--){
           rev[j] = arr[i];
           j++;
         }
         for(int i = 0; i < rev.length; i++){
             System.out.println(rev[i]);
         }

    }
    //冒泡
    public static void pao(){
        int[] arr = {4, 2, 17, 12, 322, 51};
        int cup = 0;
        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]){
                    cup = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = cup;
                
                }
            }
        }
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
    }
    
    public static void TestArray(){
        //创建一个名为TestArray的类，声明array1和array2两个变量，他们是int[]类型的数组。
        //使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
        //显示array1的内容
        //)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如 array[0] = 0,array[2] = 2)。打印出array1
        int[] array1 = {2, 3, 5, 7, 11, 13, 17, 19};
        int[] array2 = new int[]{};
        for(int i = 0; i < array1.length; i++){
            System.out.println(array1[i]);       
        }
        System.out.println();
        array2 = array1;
        for(int i = 0; i < array2.length; i++){
            if(i == 0){
                array2[0] = 0;
            }
            if(i % 2 == 0){
                array2[i] = i;
            }
        }
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
    }   
}

//注🚩：数组排序提到了插入排序、交换排序、选择排序、归并排序、基数排序，但只讲了交换排序中的冒泡排序，学完课程后建议搜索后深入了解。🚩