Arrays类

数组的工具类java.util.Arrays可以对数组进行一些基本操作。该类中的方法都是static修饰的静态方法，可以直接使用类名进行调用而不用使用对象调用

常用的Arrays工具类方法

• Arrays.toString()，输出数组为字符串
• Arrays.sort()，对数组元素进行排序
• Arrays.fill()，给数组元素赋值
• Arrays.equals()，比较两个数组是否相等
• Arrays.binarySearch()，对已排序的数组进行二分查找

import java.util.Arrays;

public class Hello {
    public static void main(String[] args) {
        int [] a = {1, 3, 2, 5, 4};
        System.out.println(a);  //直接打印数组会返回其对象名
        System.out.println(Arrays.toString(a));  //[1, 3, 2, 5, 4]，使用Arrays.toString()方法打印数组
        Arrays.sort(a);  //[1, 2, 3, 4, 5]，使用Arrays.sort()方法对数组进行排序
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.binarySearch(a, 2, 3, 2));  //1，使用Arrays.binarySearch()方法对已经排序的数组指定范围内进行二分查找，输出找到值的下标
        Arrays.fill(a, 1, 3, 0);  //[1, 0, 0, 4, 5]， 使用Arrays.fill()方法将指定下标范围的元素重新赋值，如不指定范围则全部赋值
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序

冒泡排序的时间复杂度为o(n^2)

import java.util.Arrays;

public class Hello {
    public static void main(String[] args) {
        int[] a = {5, 2, 6, 8, 4, 9, 5, 3};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
    public static void sort(int[] arrays){
        //两个变量交换值，中间变量
        int temp = 0;
        //外循环排序要进行的次数，就是元素的个数
        for (int i = 0; i < arrays.length - 1; i++) {
            boolean flag = false;
            //相邻的两个数进行比较，谁大谁换到后面，这样一轮走完，最后一个数就是最大的数
            for (int j = 0; j < arrays.length - 1 - i; j++) {  //内循环每进行一轮排序，都会找出一个最大数，因此要去掉已经排好的数，也就是-i
                if (arrays[j] > arrays[j + 1]){
                    temp = arrays[j];
                    arrays[j] = arrays[j + 1];
                    arrays[j + 1] = temp;
                    flag = true;
                }
            }
            if (flag == false){  //在内循环之前定义一个标志，如果执行了发现标志没变，说明后面已经没有数是乱序了，就结束整个循环避免浪费时间再去比较
                break;
            }
        }
    }
}

稀疏数组

当一个数组中大部分元素为0或其他值时，可以使用稀疏数组来保存该数组

稀疏数组的处理方式是：

• 记录数组一共有几行几列，有多少个不同值
• 把具有不同值的元素的行列数及值记录在一个小规模的数组里，从而缩小数组的规模

public class Hello {
    public static void main(String[] args) {
        int [][] a = new int[10][10];
        int [][] b;
        a[2][3] = 1;  //记录不同值的位置
        a[4][7] = 2;
        print(a);  //打印原数组
        System.out.println();
        b = simple(a);  //调用简化方法进行数组简化
        System.out.println();
        recovery(b);  //还原数组
    }
    //定义打印数组的方法
    public static void print(int[][] arrays){
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.print(arrays[i][j] + " ");
            }
            System.out.println();
        }
    }
    //定义简化数组的方法
    public static int[][] simple(int[][] arrays){
        int num = 0;
        for (int i = 0; i < arrays.length; i++) {  //统计原数组中值不为0的个数，称为有效值
            for (int j = 0; j < arrays[i].length; j++) {
                if (arrays[i][j] != 0){
                    num++;
                }
            }
        }
        int[][] less = new int[num + 2][3];
        less[0][0] = arrays.length;
        less[0][1] = arrays[0].length;
        less[0][2] = num;  //定义简化数组的头例，记录原数组的长度和有效值的个数
        int n = 1;
        for (int i = 0; i < arrays.length; i++) {  //将有效值的位置信息写进简化数组
            for (int j = 0; j < arrays[i].length; j++) {
                if (arrays[i][j] != 0){
                    less[n][0] = i + 1;
                    less[n][1] = j + 1;
                    less[n][2] = arrays[i][j];
                    n++;
                }
            }
        }
        System.out.println("行 列 值");
        print(less);
        return less;
    }
    //定义还原数组的方法
    public static void recovery(int[][] arrays){
        int[][] c = new int[arrays[0][0]][arrays[0][1]];  //定义一个和原数组长度一样的数组
        for (int i = 1; i <= arrays[0][2]; i++) {  //将有效值依次填入进去
            c[arrays[i][0] - 1][arrays[i][1] - 1] = arrays[i][2];
        }
        print(c);
    }
}