Day8：二维数组

二维数组的定义

Java中定义和操作多维数组的语法与一维数组类似。在实际应用中，三维以上的数组很少使用，主要使用二维数组。

数据类型[][]数组名;

数据类型 数组名[][];

数组类型为数组元素的类型。
“[][]”用于表明定义了一个二维数组，通过多个下标进行数据访问。
例：定义一个整型二维数组。

int [][]scores;//定义二维数组
scores=new int[3][50];分配内存空间
//或者
int [][]scores=new int[3][50];

注：语法上JAVA支持多维数组，但从内存分配原理来看Java中只有一维数组，没有多维数组。如该例实际上定义了一个一维数组scores,包括4个元素，分别为scores[0]、scores[1]、scores[2]、scores[3]，每个元素都是整型数组类型，即一维数组类型。而s[0]又是一个数组的名称，包括50个元素，分别为scores[0][1]……scores[0][49],每个元素都是整数类型。scores[1]、scores[2]、scores[3]与scores[0]情况相同。

二维数组的使用

1.初始化二维数组（赋值）
二维数组也可以进行初始化操作，与一维数组类似，同样可采用两种方式。

int[][] scores=new int[][]{{90,85,92,78,54},{76,63,80},{87}};

int scores[][]={{90,85,92,78,54},{76,63,80},{87}};

2.二维数组的遍历
例：分别计算每个班级的学生总成绩。
实现步骤如下：
（1）初始化整型二维数组。
（2）定义保存总成绩的变量。
（3）使用for循环遍历二维数组。

int[][]array=new int[][]{{80,66},{70,54,98},{77,59}};
//定义二维数组、分配空间、赋值
int total;//保存总成绩
for(int i=0;i<array.length;i++){
	String str=(i+1)+"班";
	total=0;//每次循环到此都将其归0
	for(int j=0;j<array[i].length;j++){
		total+=array[i][j];//成绩累加
	}
	System.out.println(str+"总成绩："+total);
}

int a [][]=new int[5][5];
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                a[i][j]=(int)(Math.random()*100);
            }
        }
        for (int i = 0; i < a.length; i++) {
            System.out.println(Arrays.toString(a[i]));
        }

Arrays类

JDK中提供了一个专门用于操作数组的工具类，即Arrays类，位于java.until包中。该类提供了一系列方法来操作数组，如排序、复制、比较、填充等。

方法	返回类型	说明
equals(array1,array2)	boolean	比较两个数组是否相等
sort(array)	void	对数组array的元素进行升序排列
toString(array)	String	将一个数组array转换成一个字符串
fill(array,val)	void	把数组array的所有元素都赋值成val
copyOf(array,length)	与array数据类型一致	把数组array赋值成长度为length的新数组
binarySearch(array)	int	查询元素val在数组array中的下标

1.比较两个数组是否相等
Arrays类的equals()方法用于比较两个数组是否相等。只有当两个数组长度相等，对应位置的元素也一一相等，该方法返回true;否则返回false。
例：初始化3个整型一维数组，使用Arrays类的equals()方法判断是否两两相等，并输出比较结果。
实现步骤如下。
（1）初始化3个整型一维数组。
（2）使用Arrays类的equals（）方法判断是否两两相等。

int []arr1={10,50,40,30};
int []arr2={10,50,40,30};
int []arr3={60,50,85};
System.out.println(Arrays.equals(arr1,arr2));//判断arr1与arr2的长度及元素是否相等。
System.out.println(Arrays.equals(arr1,arr3));//判断arr1与arr3的长度及元素是否相等。

true
false

2.对数组的元素进行升序排列
Arrays类的sort()方法对数组的元素进行升序排列，即以从小到大的顺序排列。
例：分别对1班、2班和3班的学员成绩进行升序排列。
实现步骤：
（1）初始化一个整型二维数组。
（2）使用for循环遍历二维数组。
（3）使用Arrays类的sort()方法对二维数组的元素进行升序排列。
（4）使用for循环比哪里二维数组的元素并输出。

int [][] array=new int[][]{{80,66},{70,54,98},{77,59}};
        for(int i=0;i<array.length;i++){
            String str=(i+1)+"班";
            Arrays.sort(array[i]);
            System.out.println(str+"成绩排序后：");
            for(int j=0;j<array[i].length;j++){
                System.out.println(array[i][j]);
            }
        }

1班成绩排序后：
66
80
2班成绩排序后：
54
70
98
3班成绩排序后：
59
77

3.将数组转换成字符串
Arrays类中提供了专门输出数组内容得方法——toString()方法。该方法用于转换成一个字符串。它按顺序把多个数组元素连在一起，多个数组元素之间使用英文逗号和空格隔开。利用这种方法可以很清楚地观察到各个数组元素的值。
例：初始化一个整型一维数组，使用Arrays类的toString()方法将数组转换为字符串并输出。
实现步骤如下：
（1）初始化一个整型一维数组。
（2）使用Arrays类的toString()方法将数组转换为字符串。

int a[]={1,2,3,4};
Arrays.sort(a);//将数组按升序排列
System.out.println(Arrays.toString(a));//将数组a转换为字符串并输出

[1, 2, 3, 4]

4.将数组所有元素赋值为相同的值
Arrays类的fill(array,val)方法用于把数组array的所有元素都赋值为val。
例：初始化一个整型一维数组，使用Arrays类的fill（）方法替换数组的所有元素为相同的元素。
实现步骤如下：
（1）初始化一个整型一维数组。
（2）使用Arrays类的fill()方法替换数组元素。

int []arr={8,4,9,1,7};
Arrays.fill(arr,100);//替换数组元素
System.out.println(Arrays.toString(arr));

[100, 100, 100, 100, 100]

5.将数组复制成一个长度为设定值的新数组
例：初始化一个整型一维数组，使用Arrays类的copyOf（）方法把数组复制成一个长度为设定值的新数组。
实现步骤如下：
（1）初始化一个长度为4的整型一维数组。
（2）使用Arrays类的copyOf（）方法把数组复制成一个长度为3的新数组，并输出新数组元素。
（3）使用Arrays类的copyOf（）方法把数组复制成一个长度为4的新数组，并输出新数组元素。
（4）使用Arrays类的copyOf（）方法把数组复制成一个长度为5的新数组，并输出新数组元素。

int a[]={1,2,3,4};
int a2[]=Arrays.copyOf(a,3);//将a复制长度为3的新数组a2
int a3[]=Arrays.copyOf(a,4);
int a4[]=Arrays.copyOf(a,5);
System.out.println(Arrays.toString(a2));
System.out.println(Arrays.toString(a3));
System.out.println(Arrays.toString(a4));

[1, 2, 3]
[1, 2, 3, 4]
[1, 2, 3, 4, 0]

Arrays类的copyOf（array，length）方法可以进行数组复制，把原数组复制成一个新数组，其中length是新数组的长度。如果length小于原数组的长度，则新数组就是原数组的前面length个元素；如果length大于原数组的长度，则新数组前面的元素就是原数组的所有元素，后面的元素是按数组类型补充默认的初始值，如整型补充0，浮点型补充0.0等。
6.查询元素在数组中的下标
Arrays类的binarySearch（）方法用于查询数组元素在数组中的下标。调用该方法时要求数组中的元素已经按升序排列，这样才能得到正确的结果。
例：初始化一个整型数组，使用Arrays类的binarySearch（）方法查询数组元素在数组7中的下标。
实现步骤如下：
（1）初始化一个整型数组。
（2）使用Arrays类的sort（）方法按升序排列数组。
（3）使用Arrays类binarySearch（）方法查找某个元素的下标，并输出。

int a[]={1,5,8,4};
Arrays.sort(a);//先按升序排列
int index=Arrays.binarySearch(a,5);//查找5的下标
System.out.println(index);
index=Arrays.binarySearch(a,4);//查找4的下标
System.out.println(index);

2
1

例题

例1：计算5个班各5名学生的班级总分和年级总分。

int a [][]=new int[5][5];
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                a[i][j]=(int)(Math.random()*100);
            }
        }
        for (int i = 0; i < a.length; i++) {
            System.out.println(Arrays.toString(a[i]));

        }
        int total=0;
        for (int i = 0; i < a.length; i++) {
            int sum=0;
            for (int j = 0; j < a.length; j++) {
                sum+=a[i][j];

            }
            total+=sum;
            System.out.println((i+1)+"班级的总分为："+sum);
        }
        System.out.println("年级总分："+total);

例2：冒泡排序

int a[]={121,100,98,78,89,45,22,75,33};
       //定义循环次数
        for (int i = 0; i < a.length-1; i++) {
            //循环比较过程
            boolean isChange=false;//是否有交换
            for (int j = 0; j < a.length-1-i; j++) {
                if (a[j]>a[j+1]){//前一个比后一个大，则不满足
                    //需进行交换
                    int tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                    isChange=true;//有交换
                }
            }
            System.out.println("经过"+(i+1)+"轮比较，数组变为：");
            System.out.println(Arrays.toString(a));
            if (!isChange){//本轮没有任何交换，已经有序
                System.out.println("经过"+(i+1)+"轮比较，数组已有序");
                break;
            }
        }
       /*Arrays.sort(a);
        System.out.println(Arrays.toString(a));*/

例3：各类型地址

  /*int a=1;
        double d=2.2;
        char c='h';
        String s="haha";
        System.out.println(a);
        System.out.println(d);
        System.out.println(c);
        System.out.println(s);*/
        int []a={1,2,3,4,5};
        System.out.println(a);
      /*  int b[]=a;
        a[0]=88;
        System.out.println(b);
        System.out.println(b[0]);*/
      //int b[]= Arrays.copyOf(a,a.length);
        int b[]= Arrays.copyOf(a,8);//截取长度
        System.out.println(b);//地址不同
        System.out.println(Arrays.toString(b));//内容一样
        int[] c=Arrays.copyOfRange(a,1,5);
        System.out.println(Arrays.toString(c));//范围左闭右开
        ```
例4：百钱买百鸡，有100元钱，要去买100只鸡，公鸡5元一只，母鸡3元一只，小鸡1元3只，问公，母，小鸡各买多少只
```javascript
 int a[][]=new int[1000000][3];
        int i=0;
        for(int cock=0;cock<20;cock++){
            for(int hen=0;hen<33;hen++){
                int chicken=100-cock-hen;
                if (5*cock+3*hen+chicken/3==100&&chicken%3==0){
                    a[i][0]=cock;
                    a[i][1]=hen;
                    a[i][2]=chicken;
                    i++;
                    System.out.println("公鸡有"+cock+"只，母鸡有"+hen+"只，小鸡有"+chicken+"只");
                }
            }
        }
        //int [][] rst=new int[i][3];
        int [][] rst= Arrays.copyOf(a,i);//从a到i接过来
        for (int[]r:rst){//r是rst里的每个一维数组
            System.out.println(Arrays.toString(r));
        }

       /* for(int cock=0;cock<20;cock++){
            for(int hen=0;hen<33;hen++){
                int chicken=100-cock-hen;
                if (5*cock+3*hen+chicken/3==100&&chicken%3==0){
                    System.out.println("公鸡有"+cock+"只，母鸡有"+hen+"只，小鸡有"+chicken+"只");
                }
            }
        }*/

例5：二分法查找数组。（数组要有序）

 Scanner sc=new Scanner(System.in);
        System.out.println("请输入要查找的数：");
        int num=sc.nextInt();
        int a[]={1,3,5,7,10,12,15};
        int result= Arrays.binarySearch(a,num);
        System.out.println(result<0?"没找到":"在下标为"+result+"处找到了");
        //取中，比中间大往左边，比中间小往右边；
        //无限循环，直到找到你要的数
       /* int start=0;
        int end=a.length;//-1
        while (true){
            int mid=(start+end)/2;
            if (start>end){
                System.out.println("没有");
                break;
            }
            if (start==end){
                if (start>=a.length||end<0){
                    break;
                }else if (a[mid]==num){
                    System.out.println("在下标为："+mid+"的位置找到数值："+num);
                    break;
                }
                System.out.println("没有");
                break;
            }
            if (a[mid]==num){
                System.out.println("在下标为："+mid+"的位置找到数值："+num);
                break;
            }else if (a[mid]<num){
                start =mid+1;
            }else {
                end = mid-1;
            }
        }*/