Arrays 类

Arrays 里包含了一系列的静态方法，用于管理或操作数组（比如排序和搜索）。

常用方法

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        // toString 方法，把数组元素转换成字符串
        int arr1[] = {2, 5, 6};
        System.out.println(Arrays.toString(arr1));

        // sort 方法，排序
        int arr2[] = {1, -2, 5, 7, 4, 10};
        // 因为数组是引用类型，所以通过 sort 方法排序后，会直接影响到数组本身
        Arrays.sort(arr2); // 默认升序排序
        System.out.println(Arrays.toString(arr2));

        Integer arr3[] = {1, -2, 5, 7, 4, 10};
        /**
         * sort 是重载的，可以通过传入一个接口 Comparator 实现自定义排序
         * 自定义排序时，传入两个参数：待排序的数组和实现 Comparator 接口的匿名内部类
         * 该接口要求实现 compare 方法，体现了接口编程的方式，具体可以通过debug看源码
         */
        Arrays.sort(arr3, new Comparator() {
            public int compare(Object o1, Object o2){
                Integer i1 = (Integer)o1;
                Integer i2 = (Integer)o2;
                
                // return i1 - i2; // 升序排序
                return i2 - i1; // 降序排序
            }
        });
        System.out.println(Arrays.toString(arr3));

        int arr4[] = {1, -2, 5, 7, 4, 10};
        // 以冒泡排序为例，采用 Comparator 接口实现自定义排序
        bubble(arr4, new Comparator() {
            @Override
            public int compare(Object o1, Object o2){
                int i1 = (Integer)o1;
                int i2 = (Integer)o2;

                // 调用 compare 方法返回一个数，用于判断排序的标准（升序还是降序）
                return i1 - i2;
            }
        });
        System.out.println(Arrays.toString(arr4));

        // binarySearch 方法，通过二分搜索法进行查找，要求必须排好序
        Integer arr5[] = {1, 2, 12, 14, 15, 47, 99}; //  要求数组是有序的（可升序或者降序）
        // 找到返回元素的索引，
        // 通过看源码，如果找不到元素，则返回 -(low + 1)
        // low 表示所查找的元素如果在数组中时，它的索引
        // 比如查找 3, 3不存在，如果3在数组中，则它的索引是2，即 low = 2，所以会返回-3 
        int index = Arrays.binarySearch(arr5, 14);
        System.out.println(index); // 3
        System.out.println(Arrays.binarySearch(arr5, 3)); // -3

        // copyOf 数组元素的复制
        // 从 arr5 数组中，复制 arr5.length 个元素放在 arr6 中
        // 如果第二个参数大于 arr5 数组的长度，则多出的部分会用 null 填充
        // 如果第二个参数小于0，则会抛出异常
        Integer arr6[] = Arrays.copyOf(arr5, arr5.length);
        System.out.println(Arrays.toString(arr6));

        // fill 数组元素的填充
        Integer arr7[] = {1, 2, 3};
        // 用 99 替换掉数组中的所有元素
        Arrays.fill(arr7, 99);
        System.out.println(Arrays.toString(arr7)); // [99, 99, 99]

        // equals 比较两个数组元素内容是否一致
        Integer arr8[] = {99, 99, 99};
        System.out.println(Arrays.equals(arr7, arr8)); // true

        // asList 将一组值，转换成 List , 即将数组转换成集合
        List asList = Arrays.asList(arr8);
        System.out.println(asList); // [99, 99, 99]
        // 输出：asList 的运行类型：class java.util.Arrays$ArrayList
        System.out.println("asList 的运行类型：" + asList.getClass());
    }


    // 以冒泡排序为例，采用 Comparator 接口实现自定义排序
    public static void bubble(int[] arr, Comparator c) {
        int t = 0;

        for(int i = 0; i < arr.length - 1; i++){
            for(int j = 0; j < arr.length - 1 - i; j++){
                // if(arr[j] > arr[j+1]){ // 按升序还是降序由此语句判断
                // 现在采用 Comparator 接口可以实现自定义排序，即由用户决定是升序还是降序
                // 而不是写死
                // c.compare(arr[j], arr[j+1]) 方法的返回值决定了排序是升序还是降序
                if(c.compare(arr[j], arr[j+1]) > 0){
                    t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                }
            }
        }
    } 
}