java--冒泡排序+Arrays工具类常用方法--二维数组

第七章-二维数组

1、经典排序–冒泡排序 – 升序

原理：
每次比较相邻两数
小的交换到前面
每轮结束后最大的数交换到最后

口诀：
冒泡排序速记口诀（升序）
n 个数字来排队
两两相比小靠前
外层循环 n-1
内层循环 n-1-i

示例：

   // 冒泡排序算法
    int[] scores = new int[] { 16, 25, 9, 90, 23 };
    System.out.println("排序前：");
    System.out.println(Arrays.toString(scores));
    for (int i = 0; i < scores.length - 1; i++) {
        for (int j = 0; j < scores.length - 1 - i; j++) {
            // 两两比较，如果前面值大于后面，值互换
            if(scores[j] < scores[j+1]){
                int temp = scores[j];
                scores[j] = scores[j+1];
                scores[j+1] = temp;
            }
        }
    }
    System.out.println("排序后：");
    System.out.println(Arrays.toString(scores));

2、Arrays工具类的用法

1. 比较array1和array2两个数组是否相等

boolean equals(array1,array2)

2. 对数组array的元素进行升序排列

sort(array)

3. 将一个数组array转换成一个字符串

String toString(array)

4. 把数组array所有元素都赋值为val

void fill(array,val)

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

copyOf(array,length)

6. 查询元素值val在数组array中的下标（要求数组中元素已经按升序排列）

int binarySearch(array, val)

示例：

  // Arrays工具类对数组的常用方法
        // 判断数组是否相等--依次比较数组的元素是否完全一致，包括元素个数
        int[] arr1 = {1,2,3,4};
        int[] arr2 = {1,2,3,4,0};
        
        System.out.println("数组是否相等：" + Arrays.equals(arr1, arr2));
        
        // 数组排序，默认是升序，调用方法后，数组内容就改变了
        int[] arr3 = {2,3,1,4,8,6};
        Arrays.sort(arr3);
        System.out.println("sort排序后：" + Arrays.toString(arr3));
        
        // 填充数组元素为某个值
        int[] arr4 = new int[5];
        Arrays.fill(arr4, 2);
        System.out.println("fill赋值后：" + Arrays.toString(arr4));
        
        // 拷贝数组，长度是可以增加或者减少
        int[] arr5 = {23,34,45,6,12};
        int[] arr6 = Arrays.copyOf(arr5, 10);
        System.out.println("copyOf拷贝后，新数组：" + Arrays.toString(arr6));
        
        // 数组查找元素，前提必须是数组元素都是升序排序的
        int[] arr7 = {1,3,5,4,2,9,6};
        Arrays.sort(arr7);
        System.out.println("查找包含4的元素的下标：" + Arrays.binarySearch(arr7, 4));
        System.out.println("查找是否包含3的元素？：" + (Arrays.binarySearch(arr7, 3) >= 0));

3、二维数组

语法：
<数据类型> [ ][ ] 数组名 = new 数据类型[数组二维长度][数组一维长度];
或者
<数据类型> 数组名[ ][ ] = new 数据类型[数组二维长度][数组一维长度];
注意：
定义二维数组时，要定义最大维数，一维维度可以不定义，且长度不是必须一致的
二维数组实际上是一个以一维数组做为元素的一维数组

示例：

  int [ ][ ] scores = new int[5][]; -- 正确
    int [ ][ ] scores = new int[][]; -- 错误

定义并赋值：

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

示例：
按规律输出数字列表

    // 按规律输出数字列表
    /*1  0  0  0  0  0
      2  7  0  0  0  0
      3  8 12  0  0  0
      4  9 13 16  0  0
      5 10 14 17 19  0
      6 11 15 18 20 21*/
    Scanner input = new Scanner(System.in);
    System.out.print("请输入一个数字:");
    int length = input.nextInt();
    // 定义一个二维数组,直接访问length属性返回的是最大维度值
    int[][] nums = new int[length][length];
    // System.out.println("数组长度：" + nums.length);
    int count = 1;
    for (int i = 0; i < nums.length; i++) {
        for (int j = i; j < nums[i].length; j++) {
            nums[j][i] = count;
            count++;
        }
    }

    // 循环输出
    for (int i = 0; i < nums.length; i++) {
        for (int j = 0; j < nums.length; j++) {
            if(nums[i][j] != 0){
                System.out.print(nums[i][j] + "  ");
            }
        }
        System.out.println();
    }