Arrays类与二维数组

一、Arrays类

除了上一篇文章提到的几种Arrays方法，Arrays类还有其他方法。

1.Arrays.copyOf(array,length)

把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致。

        int[] nums = {11,25,69,86,76,34};

        int[] newnums1=Arrays.copyOf(nums, 3);
        System.out.println(Arrays.toString(newnums1));
        
        int[] newnums2=Arrays.copyOf(nums, 6);
        System.out.println(Arrays.toString(newnums2));
        
        int[] newnums3=Arrays.copyOf(nums, 8);
        System.out.println(Arrays.toString(newnums3));

结果：

[11, 25, 69]
[11, 25, 69, 86, 76, 34]
[11, 25, 69, 86, 76, 34, 0, 0]

2.Arrays.binarySearch(array, val)

查询元素值val在数组array中的下标（要求数组中元素已经按升序排列）,如果数组中没有你要查找的元素，返回一个负值。

public static void main(String[] args) {
        
        int[] nums = {11,25,63,11,25,45,96,63};
        
        Arrays.sort(nums);
        
        System.out.println(Arrays.toString(nums));

        int index =Arrays.binarySearch(nums, 630);

        System.out.println("25在数组中的下标为："+index);

    }

结果：

[11, 11, 25, 25, 45, 63, 63, 96]
25在数组中的下标为：-9

3.Arrays.copyOfRange(int[] original, int from, int to) 将指定数组的指定范围复制到一个新数组。 复制的范围包括开始索引，不包括结束索引

public static void main(String[] args) {
        int[] nums = {11,25,69,78,46,12,13,66,88,99,40};
                     
        int[] newNums =Arrays.copyOfRange(nums, 3, 7);

        System.out.println(Arrays.toString(newNums));
    }

结果：

[78, 46, 12, 13]

二、二维数组

多维数组：也就是数组的嵌套，即一个数组中包含一个或者多个数组。

1.二维数组的声明 

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

        byte[][] bytes;
        short[][] shorts;
        int[][] nums;
        String[][] strs;

 2.分配空间：告诉数组里面的元素个数

数组名 = new 数据类型[长度][长度]; 或者 数组名 = new 数据类型[数组长度][];

        // nums数组中有4个元素，这4个元素都是一个一维数组，并且这4个一维数组的长度都为3
        nums = new int[4][3];

        // strs数组中有3个元素，这3个元素都是一维数组，这3个一维数组的长度可能不相同
        strs = new String[3][];

        // 赋值：将数据存储在数组中 数组名[下标][下标]
        nums[0][0] = 10;
        nums[0][1] = 23;
        nums[0][2] = 33;

        nums[1][0] = 20;
        nums[1][1] = 33;
        nums[1][2] = 13;

        nums[2][0] = 40;
        nums[2][1] = 13;
        nums[2][2] = 73;

        nums[3][0] = 10;
        nums[3][1] = 83;
        nums[3][2] = 45;
        // nums数组中每个元素（一维数组）的长度为3，下标范围0-2.下标为3，超出范围，报数组下表越界异常
        // nums[3][3] = 77;

        System.out.println(nums[3][2]);

3.操作数组中的元素 数组名[下标][下标]

        nums[3][2]+=20;// nums[3][2]=nums[3][2]+20;
        System.out.println(nums[3][2]);

4.二维数组的声明和分配空间合并写

  数据类型[][] 数组名 = new 数据类型[长度][长度]; 或者 数据类型[][] 数组名 = new 数据类型[长度][];
        
        //声明一个长度为2的二维数组，这个二维数组的元素还是一个数组，每个数组的长度是4
        int[][] nums = new int[2][4];
        
        //声明一个长度为3的二维数组，这个二位数的元素还是一维数组，每个一维数组的长度不确定
        char[][] chars = new char[3][];
        
        

5.二维数组的声明、分配空间、赋值、合并写

       数据类型[][] 数组名 = new 数据类型[][]{{数据1,数据2,...,数据n},{数据1,数据2,...,数据n},...,{数据1,数据2,...,数据n}};

        double[][] doubles = new double[][]{{12.5,45.8},{23.4,56.1,58.3}};

6.二维数组声明、分配空间、赋值的简写方式

         数据类型[][] 数组名={{数据1,数据2,...,数据n},{数据1,数据2,...,数据n},...,{数据1,数据2,...,数据n}};

        int[][] nums = {{11,25,36},{44,66},{1,2,3,8,9,45}};

7.二维数组的遍历

        int[][] nums = { { 11, 23, 45 }, { 25, 36 },
                { 55, 66, 44, 78, 95, 123, 68 }, { 100 } };

        for (int i = 0; i < nums.length; i++) {
            // System.out.println(nums[i]);
            //因为nums是一个二维数组，nums[i]表示的是nums数组中的元素，而这个元素还是一个一维数组，所以需要继续对nums[i]进行遍历
            for(int j =0;j<nums[i].length;j++){
                System.out.print(nums[i][j]+" ");
            }
            //换行
            System.out.println();
        }

示例：

public static void main(String[] args) {
        // 已知有3个班级各5名学员，请使用二维数组计算各个班级的总成绩

        // 创建Scanner类对象
        Scanner sc = new Scanner(System.in);

        // 准备一个长度为3的二维数组，存储学生成绩
        double[][] scores = new double[3][5];

        // 通过循环向scores数组中赋值
        for (int i = 0; i < scores.length; i++) {
            System.out.println("*************第" + (i + 1) + "个班*************");
            for (int j = 0; j < scores[i].length; j++) {
                System.out.println("请输入第" + (j + 1) + "个学生成绩：");
                scores[i][j] = sc.nextDouble();
            }
        }

        // 遍历输出二维数组中的元素
        for (int i = 0; i < scores.length; i++) {
            System.out.print("第" + (i + 1) + "个班学生成绩：");
            for (int j = 0; j < scores[i].length; j++) {
                System.out.print(scores[i][j] + " ");
            }
            System.out.println();
        }

        //定义一个变量来存储所有学生成绩之和
        double allSum = 0;
        
        
        for (int i = 0; i < scores.length; i++) {
            // 计算每个班的成绩之和
            double sum = 0;
            System.out.print("第" + (i + 1) + "个班总成绩：");
            for (int j = 0; j < scores[i].length; j++) {
                sum += scores[i][j];
                allSum+=scores[i][j];
            }
            System.out.println(sum);
        }
        
        System.out.println("所有学生成绩值之和："+allSum);

    }