【韩老师零基础30天学会Java 03】可变参数 二分查找工具类 翻转数组 二维数组 稀疏数组和还原，可变三角形，杨辉三角

数组操作

可变参数

        printMax(1, 23, 4);
        
        
	public static void printMax(double... num) {
        if (num.length == 0) {
            System.out.println("参数异常");
            return;
        }

        //第 0 个值
        double res = num[0];

        //从 第 1 个开始，循环到最大索引
        for (int i = 1; i < num.length; i++) {
            //如果 当前的值 > 大于 要返回的值
            if (num[i] > res) {
                //就把 当前的值 赋值给返回的值
                res = num[i];
            }
        }
        //输出返回的值
        System.out.println(res);

    }

二分查找工具类

        import java.util.Arrays;
        
        int[] a2 = new int[]{1, 2, 3, 5};
        //Arrays.fill(a2, 0);
        //返回1，在2在1索引上
        System.out.println(Arrays.binarySearch(a2, 2));
		//如果查不到，返回
		//return -(a.length + 1);  // key not found.

翻转数组

        int[] arrR = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(reverse(arrR)));

    public static int[] reverse(int[] arr) {
        //数组的长度
        int arrLength = arr.length;
        //再次创建一个数组
        int res[] = new int[arrLength];

        //从0开始 循环，循环到最大索引。j的值为 最大索引，每次-1
        /*for (int i = 0, j = arrLength - 1; i < arrLength; i++, j--) {
            res[j] = arr[i];
        }*/

        //j为最大索引
        int j = arrLength - 1;
        for (int i = 0; i < arrLength; i++) {
            //使用后，j--
            res[j--] = arr[i];
        }

        return res;
    }

二维数组

• 一维数组的 每一个元素，又是一个数组。

1) 一维数组的声明方式有:
int[] x 或者 int x[]

2) 二维数组的声明方式有:
int[][] y 或者 
int[] y[] 或者 
int y[][]

遍历

        int arr[][] = new int[4][6];// 有几个一维数组（二维数组有几个元素），一维数组有几个元素
        arr[1][2] = 1;
        arr[2][1] = 2;
        arr[2][3] = 3;

        int arr[][] = {{0, 0, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 2, 0, 3, 0, 0}, {0, 0, 0, 0, 0, 0}};

        for (int i = 0; i < arr.length; i++) {
            System.out.println(Arrays.toString(arr[i]));
        }

        /*for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }*/

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

访问3
3在 第3个一维数组的，第4个值，所以为：arr[3-1][4-1]

基本赋值

        //int [3][2]
        int[][] array = {{1, 2}, {3, 4}, {5, 6}};

        System.out.println(array.length); //数组长度为3

        System.out.println(array[0].length);//第一个索引的数组，长度为2

        System.out.println(array[2][1]);//3位置的 第2个数，为 6

        int[][] arr2 = new int[3][2];
		//3位置，第二个数，赋值为7
        arr2[2][1] = 7;
        System.out.println(arr2[2][1]);

统计有多少值

        int[][] arr = new int[4][4];
        arr[1][2] = 1;
        arr[2][3] = 2;

        int count = 0;
        for (int[] as : arr) {
            for (int a : as) {
                System.out.print(a + "\t");
                if (a != 0) {
                    ++count;
                }
            }
            System.out.println();
        }

0	0	0	0	
0	0	1	0	
0	0	0	2	
0	0	0	0	

    count 的值为 2

稀疏数组

        //有2个值，就要存3行。0索引 存原始的行列信息。列：固定为3列（行 列 位置+值）。
        //如：3行3列，为3个一维数组，每个一维数组3个值。
        int[][] arr2 = new int[count + 1][3];

        //4行，4列，有效元素个数。
        arr2[0][0] = 4;//原数组4行
        arr2[0][1] = 4;//4列
        arr2[0][2] = count;//有值的数量

        //稀疏数组的坐标
        int index = 0;

        //遍历 原始数组。固定原始的2层遍历。
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                //具体的值
                int t = arr[i][j];

                //如果值不为空
                if (t != 0) {
                    index++;
                    //存 行列 和 值。因为：元数组，也是从0开始索引的，所以无需+1
                    arr2[index][0] = i;//行号
                    arr2[index][1] = j;//列号
                    arr2[index][2] = t;//具体的值
                }//判空

            }//内层循环
        }//外层

        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i][0] + "\t" + arr2[i][1] + "\t" + arr2[i][2]);
        }

0	0	0	0	//原数组
0	0	1	0	
0	0	0	2	
0	0	0	0	

4	4	2 //原数组是 4行 4列的，有2个值
1	2	1 //第一个值在 第2行3列上，值为1
2	3	2 //第二个值在 第3行4列上，值为2

稀疏数组还原

        //取出原数组的行数
        int row = arr2[0][0];
        //取出原数组的列数
        int col = arr2[0][1];
        //定义 原数组的长度
        int[][] originalArr = new int[row][col];

        //从1开始遍历，到 稀疏数组的长度，本次为3
        for (int i = 1; i < arr2.length; i++) {
            //行 列 值
            int hang = arr2[i][0];
            int lie = arr2[i][1];
            //真实 行列位置，赋上 原来的值
            originalArr[hang][lie] = arr2[i][2];
        }

        for (int[] as : originalArr) {
            for (int a : as) {
                System.out.print(a + "\t");
            }
            System.out.println();
        }

=========还原了======
0	0	0	0	
0	0	1	0	
0	0	0	2	
0	0	0	0	

可变二维数组三角形

        /*
        看一个需求： 动态创建下面二维数组， 并输出
        i = 0: 1
        i = 1: 2 2
        i = 2: 3 3 3
        一个有三个一维数组, 每个一维数组的元素是不一样的
        */
        //创建 二维数组， 一个有 3 个一维数组， 但是每个一维数组还没有开数据空间
        int[][] arr = new int[3][]; //改成N就是N个
        for (int i = 0; i < arr.length; i++) {//遍历 arr 每个一维数组
            //给每个一维数组开空间 new
            //如果没有给一维数组 new ,那么 arr[i]就是 null
            arr[i] = new int[i + 1];
            //遍历一维数组， 并给一维数组的每个元素赋值
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = i + 1;//赋值
            }
        }

        //遍历 arr 输出
        for (int i = 0; i < arr.length; i++) {
            //输出 arr 的每个一维数组
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();//换行
        }

1 
2 2 
3 3 3

int[][] arr = {{1,1,1}, {8,8,9}, {100}};

//第一个一维数组有 3 个元素 , 第二个一维数组有 3 个元素, 第三个一维数组有 1 个元素

杨辉三角

1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1 

• 写法1

        /*
        规律
        1.第一行有 1 个元素, 第 n 行有 n 个元素
        2. 每一行的第一个元素和最后一个元素都是 1
        3. 从第三行开始, 对于非第一个元素和最后一个元素的元素的值. arr[i][j]
        arr[i][j] = arr[i-1][j] + arr[i-1][j-1]; //必须找到这个规律
        */
        int[][] yangHui = new int[12][];
        for (int i = 0; i < yangHui.length; i++) {//遍历 yangHui 的每个元素
            //给每个一维数组(行) 开空间
            yangHui[i] = new int[i + 1];
            //给每个一维数组(行) 赋值
            for (int j = 0; j < yangHui[i].length; j++) {
                //每一行的第一个元素和最后一个元素都是 1
                if (j == 0 || j == yangHui[i].length - 1) {
                    yangHui[i][j] = 1;
                } else {//中间的元素
                    yangHui[i][j] = yangHui[i - 1][j] + yangHui[i - 1][j - 1];
                }
            }
        }

• 写法2

            //首元素赋值为1
            arr[i][0] = 1;
            //最大索引
            int maxIndex = arr[i].length - 1;
            //最大索引赋值为1
            arr[i][maxIndex] = 1;

            //0 1 2(从第三行开始)
            if (i > 1) {
                //从1索引开始，到 最大索引-1
                for (int j = 1; j < maxIndex; j++) {
                    //当前的值为 = 上一行的元素 + 上一行的前一个元素
                    arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
                }
            }