数组

概念：一组相同类型的数据的组合

     数组也是一种引用类型，

名称：数组名称不是固定的，与存放的数据的类型有关。

• 数组中只能存一种类型的数据
  如: 存放一组int类型的数据，
  数组名称 int[]

      存放一组字符串数据
      数组名称   String[]
  
      存放一组Scanner类型的数据
      数组名称   Scanner[]
  
      存放一组字符类型的数据
      数组名称   char[]
  

元素的概念：

  数组中的每个数据，都是这个数值的元素。

数组的声明与初始化

 声明：元素类型[]  变量名;
       元素类型   变量名[];--不建议此写法
 变量的初始化的时机：2种
   (1)声明时直接初始化
   (2)先声明，再初始化(使用前初始化)
 数组的变量初始化：3种情况
       (1)静态初始化
      String[] names = {"A","B"};
      int[] nums = {};

  
   (2)动态初始化
      --规定数组长度的写法
        int[] ages = new int[length];

    
    其实有默认元素：
    整数类型：默认是0
    浮点数类型：默认0.0
    字符类型：默认'\u0000'
    布尔类型：默认false
    引用数据类型：默认值null


      --不规定长度的写法
    int[] ages = new int[]{};
    double[] counts = new double[]{1.2,3.14};

数组的长度：

 即数组元素的个数
 表示方式：变量名.length;

数组的下标(index):

  下标从0开始，最后一个元素的下标为：length-1;
  下标范围：0~length-1

数组元素的访问(查看):

  通过下标进行查看
  语法:变量名[index];

元素的遍历(从头到尾依次查看)
for(int i=0;i<变量名.length;i++){
System.out.println(变量命[i]);
}

数组元素的覆盖(赋值，替换)

  语法：变量名[index] = value;

数组间的赋值

数组间的变量赋值：
通过一个变量对数组的元素进行修改，
那么与之相关的变量对应的数组的元素
也会发生变化。
如：
int[] a = {1,2,3};
int[] b = a;
通过b修改元素，a对应的数组也跟着改变

           数组是引用数据类型，在变量中村的是地址。

数组下标越界异常：

java.lang.ArrayIndexOutOfBoundsException

出现的原因：
    访问数组元素时的下标超出了范围[0~length-1]，属于运行时异常，

    数组下标越界异常，编译器检查不出来此异常
    运行时才会出现，出现的结果造成了程序的中断结束。
正确范围：0~length-1
错误下标：
       变量名[-1]
       变量名[length]

引用类型之Arrays

是数组的工具类。此类提供了很多对数组操作的功能方法
如：

在使用工具类时，一定要先到包。不然会出现错误
String info = Arrays.toString(数组名);
Arrays.toString():此方法是将数组的元素
一一拼接成字符串.(一定要是数组)

格式如下：
   "[元素1,元素2,.....元素length-1]"

数组的复制

 数组的特点：一经创建，长度不可变。

 系统复制法：
   System.arraycopy(src,start1,des,start2,length);
   src:源数组，即被复制的数组名
   start1:源数组复制的开始下标
   des:目标数组，即复制到的数组名
   start2:目标数组复制的开始下标
   length:复制的长度

    int[] nums = {99,100,98,99,100};
    int[] num1 = new int[nums.length];//{0,0,0,0,0}
    System.arraycopy(nums,0,num1,0,nums.length);
    System.out.println("num1:"+Arrays.toString(num1));

 工具类提供的复制方法:
  元素类型[] 变量名=Arrays.copyOf(src,newLength);
  src:源数组
  newLength:新数组的长度

 功能解释：从src的下标为0的元素开始复制
           复制到长度为newLength的新数组中
       新数组存放元素的开始位置为0

（可以对复制的数组进行扩容何人缩容）

  数组的练习：  

    /* 定义一个字符串数组names,
       存储10个学生的姓名*/
    String[] names = new String[10];
    for(int i=0;i<names.length;i++){
        names[i] = "小"+(char)(i+65);
    }
    for(int i=0;i<names.length;i++){
        System.out.print(names[i]+" ");
    }
    /* 定义一个int数组scores,用于存储这10个学生的
       成绩，成绩使用随机数 [90,100]   
        计算成绩的平均值
        找到成绩的最大值，并输出其姓名
        找到成绩的最小值，并输出其姓名
       */
    System.out.println();
    int[] scores = new int[names.length];
    for(int i=0;i<scores.length;i++){
        scores[i] = (int)(Math.random()*11+90);
    }
    for(int i=0;i<scores.length;i++){
        System.out.print(scores[i]+" ");
    }
    /* 计算平均值：*/
    int sum = 0;
    for(int i=0;i<scores.length;i++){
        sum+=scores[i];
    }
    double avg_score = sum*1.0/scores.length;
    System.out.println("平均成绩为："+avg_score);
    /* 找最大值 */
    int max = -1;//用于存入最大值
    int min = 101;//用于存储最小值
    for(int i=0;i<scores.length;i++){
        if(max<scores[i]){
            max = scores[i];//将较大值的成绩存入max
        }
        if(min>scores[i]){
            min = scores[i];//将较小值的成绩存入min
        }
    }
    System.out.println("最高成绩："+max);
    System.out.println("最低成绩："+min);

 /*
    需要知道最高成绩的下标，才能知道人名
    而最高成绩的下标可能有多个。需要保存
    到一个新数组里

    最低成绩同上。    
    */
    int h_count = 0;
    int l_count = 0;
    for(int i=0;i<scores.length;i++){
        if(max==scores[i]){
            h_count++;//统计最高成绩的个数
        }
        if(min==scores[i]){
            l_count++;//统计最低成绩的个数
        }
    }
    /*
       将最高/最低成绩的下标：
       存入新数组中
    */
    
    int[] max_indexs = new int[h_count];//用来存储最高成绩的多个下标
    int max_count=0;//用来下标的自增
    
    int[] min_indexs = new int[l_count];//用来存储最低成绩的多个下标
    int min_count=0;//用来下标的自增

    for(int i=0;i<scores.length;i++){
        if(scores[i]==max){
            max_indexs[max_count] = i;//找到最大值的下标，并存入新数组
            max_count++;//为下一次存储做准备
        }
        if(scores[i]==min){
            min_indexs[min_count++] = i;
        }
    }
    /*输出 最高成绩的姓名和分数       
      从存储下标的数组中，取出值，此值是
      names数组的下标
    
    */
    for(int i=0;i<max_indexs.length;i++){
        int v = max_indexs[i];
        System.out.println(names[v]+":"+scores[v]);
    }

    /*输出 最低成绩的姓名和分数*/
    for(int i=0;i<min_indexs.length;i++){
        int v = min_indexs[i];//
        System.out.println(names[v]+":"+min);
    }
 }

二维数组：

概念：数组的元素依然是数组
int[] a = {1,2,3,4}
int[][] b={{1,2},{2,3,4,5,6},{1,2,3}}
访问： b[0]–>{1,2}
b[1]–>{2,3,4,5,6}
b[2]–>{1,2,3}

   b[0][0] -->1
   b[0][1] -->2
   .....
   b[1][3] -->5
   b[1][4] -->6
   ...
   b[2][1] -->2
   x={
      {1,2,3},
      {1,2,3},
  {4,5,6}
     }

   x数组的元素：都是等长的数组，类似于矩阵。

   y ={
   {1,2},
   {1,2,3},
   {1}
      }
   y数组的元素：不是等长的数组。

二维数组的初始化：
静态初始化
如：int[][] a = {{1},{1,2},{2,3,4}};

动态初始化：
(1)等长式初始化
int[][] a = new int[3][2];

  表示a有三个元素，每个元素都是2个长度的数组。
  (2)只规定高维数组的长度
      int[][] a = new int[3][];
  表示a有三个元素，但是都是null.
  null在使用时，需要新建数组对象(长度任意)

    int[][] c = new int[3][];
    //输出c的第一个元素
    System.out.println(c[0]);//null  数组只有长度没有元素{}
    c[0] = new int[2];//将null替换成数组对象，如果是以上初始化方法，一定要有这一步
    System.out.println(Arrays.toString(c[0]));
    c[0][0] = 1;
    c[0][1] = 2;
    System.out.println(c[0]);
    System.out.println(Arrays.toString(c[0]));

二维数组的练习

   /*录入5个学生的数学，语文，英语三科成绩
      计算每科的平均成绩与每人的平均成绩
      并找出每科成绩的最高分与最低分。
    */

    //以学生为主体，录入每个学生的3科，此处也可以以科目为主题，录入每个学生，

    //数组定义变为 int[3][5]
    int[][] scores = new int[5][3];
    Scanner sc = new Scanner(System.in);
    for(int i=0;i<scores.length;i++){

    //分别录入每个学生三科成绩
        System.out.println("录入第"+(i+1)+"个学生的成绩");
        for(int j=0;j<scores[i].length;j++){
            scores[i][j]=sc.nextInt();    
        }
    }
    /*查看 每个学生的成绩*/
    for(int i=0;i<scores.length;i++){
        System.out.println("学生"+(i+1)+":"+Arrays.toString(scores[i]));
    }
    /*计算每个学生的总成绩和平均成绩
        int sum = 0;
        sum+=scores[0][0];
        sum+=scores[0][1];
        sum+=scores[0][2];
        sum/3.0;

        int sum = 0;
        sum+=scores[1][0];
        sum+=scores[1][1];
        sum+=scores[1][2];
        sum/3.0;

        .....
    */
    for(int i=0;i<scores.length;i++){
        int sum = 0;
        for(int j=0;j<scores[i].length;j++){
            sum+=scores[i][j];
        }
        System.out.println("学生"+(i+1)+"的总成绩："+sum+",平均成绩："+(int)((sum/3.0)*100)/100.0);
    }
    /*
        计算每科的总成绩和平均成绩
        int total_sum = 0;
        total_sum+=scores[0][0];
        total_sum+=scores[1][0];
        total_sum+=scores[2][0];
        total_sum+=scores[3][0];
        total_sum+=scores[4][0];
        total_sum+=scores[5][0];
        .....
        total_sum/10.0

        int total_sum = 0;
        total_sum+=scores[0][1];
        total_sum+=scores[1][1];
        total_sum+=scores[2][1];
        total_sum+=scores[3][1];
        total_sum+=scores[4][1];
        total_sum+=scores[5][1];
        .....
        total_sum/10.0

        int total_sum = 0;
        total_sum+=scores[0][2];
        total_sum+=scores[1][2];
        total_sum+=scores[2][2];
        total_sum+=scores[3][2];
        total_sum+=scores[4][2];
        total_sum+=scores[5][2];
        .....
        total_sum/10.0
    
    */
    /*
      顺便统计每科的最高分与最低分
    */
    for(int i=0;i<scores[0].length;i++){
        int total_sum = 0;
        int max = -1;
        int min = 101;
        for(int j=0;j<scores.length;j++){
            total_sum+=scores[j][i];

            if(max<scores[j][i]){
                max = scores[j][i];
            }
            if(min>scores[j][i]){
                min = scores[j][i];
            }
        }
        System.out.println("学科"+(i+1)+"的总成绩："+total_sum+",平均成绩："+total_sum/10.0+",最高分："+max+",最低分："+min);
    }
}

引用类型数组：
基本数据类型数组，元素是基本类型的数据
引用数据类型数组，元素是对象
初始化的方式
静态初始化：
元素类型[] 变量名 = {}
动态初始化
规定长度
元素类型[] 变量名 = new 元素类型[]
不规定长度：
元素类型[] 变量名 = new 元素类型[]{}
引用数据类型的数组使用规定长度的方式进行初始化
默认值是null；存入元素时，需要新建对象存入；
如：
Cell[] cs = new Cell[10];
cs里有地址，数组对象的地址，此对象里有10个null
第一个元素存储（0，3）的方格
cs[0]= new Cell(0,3)
第一个元素存储（0，4）的方格
cs[1]= new Cell(0,4)
引用类型的数组内，存储的是元素对象的地址信息