JAVA Arrays类详解（韩顺平）

我是康康康

已于 2022-05-06 19:33:49 修改

阅读量686

点赞数 4

文章标签： java 蓝桥杯开发语言

于 2022-05-06 19:32:41 首次发布

本文链接：https://blog.csdn.net/wztmds/article/details/124616675

版权

一.Arrays常用方法

1.toString 返回数组的字符串形式

2.sort排序（自然排序和定制排序——后面详见）

3.binarySearch通过二分搜索法进行查找，要求必须排好序

一.Arrays常用方法

1.toString 返回数组的字符串形式

Integer[] integers = {1, 20, 90};
//        遍历数组
        for(int i = 0; i < integers.length; i++) {
            System.out.println(integers[i]);
        }
//        直接使用Arrays.toString方法，显示数组
        System.out.println(Arrays.toString(integers));

2.sort排序（自然排序和定制排序——后面详见）

int[] a1 = {2,3,1,0,34,-1};
        Arrays.sort(a1);
        for (Object o :a1) {
            System.out.println(o);
        }

3.binarySearch通过二分搜索法进行查找，要求必须排好序

int[] a1 = {2,3,1,0,34,-1};
        Arrays.sort(a1);
        for (Object o :a1) {
            System.out.println(o);
        }

        System.out.println(Arrays.toString(a1));
        System.out.println("=========");
        System.out.println(Arrays.binarySearch(a1,2));
        //如果数组中不存在该元素，就返回 return -(low + 1);  // key not found.

4.copyOf数组元素的复制

        int[] arr = {1,2,3,1,3};
        //1. 从 arr 数组中，拷贝 arr.length个元素到 newArr数组中
        //2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
        //3. 如果拷贝长度 < 0 就抛出异常NegativeArraySizeException
        //4. 该方法的底层使用的是 System.arraycopy()
        Integer[] newArr = Arrays.copyOf(arr, arr.length);
        System.out.println("==拷贝执行完毕后==");
        System.out.println(Arrays.toString(newArr));

5.fill数组元素的填充

Integer[] num = new Integer[]{9,3,2};
        //1. 使用 99 去填充 num数组，可以理解成是替换原理的元素
        Arrays.fill(num, 99);
        System.out.println("==num数组填充后==");
        System.out.println(Arrays.toString(num));

6.asLis将一组值，转换成list

//1. asList方法，会将 (2,3,4,5,6,1)数据转成一个List集合
        //2. 返回的 asList 编译类型 List(接口)
        //3. asList 运行类型 java.util.Arrays#ArrayList, 是Arrays类的
        //   静态内部类 private static class ArrayList<E> extends AbstractList<E>
        //              implements RandomAccess, java.io.Serializable
        List asList = Arrays.asList(2,3,4,5,6,1);
        System.out.println("asList=" + asList);
        System.out.println("asList的运行类型" + asList.getClass());

二.sort排序源码分析

Integer arr[] = {1, -1, 7, 0, 89};
        //进行排序
        //1. 可以直接使用冒泡排序 , 也可以直接使用Arrays提供的sort方法排序
        //2. 因为数组是引用类型，所以通过sort排序后，会直接影响到 实参 arr
        //3. sort重载的，也可以通过传入一个接口 Comparator 实现定制排序
        //4. 调用 定制排序 时，传入两个参数 (1) 排序的数组 arr
        //   (2) 实现了Comparator接口的匿名内部类 , 要求实现  compare方法
        //5. 先演示效果，再解释
        //6. 这里体现了接口编程的方式 , 看看源码，就明白
        // 源码分析
        //(1) Arrays.sort(arr, new Comparator()
        //(2) 最终到 TimSort类的 private static <T> void binarySort(T[] a, int lo, int hi, //int start,
                                               Comparator<? super T> c)()
        //(3) 执行到 binarySort方法的代码, 会根据动态绑定机制 c.compare()执行我们传入的
        //  匿名内部类的 compare ()
             while (left < right) {
                        int mid = (left + right) >>> 1;
                        if (c.compare(pivot, a[mid]) < 0)
                            right = mid;
                        else
                            left = mid + 1;
                    }
        (4) new Comparator() {
                    @Override
                    public int compare(Object o1, Object o2) {
                        Integer i1 = (Integer) o1;
                        Integer i2 = (Integer) o2;
                        return i2 - i1;//可以根据要求进行从大到小或从小到大排序
                    }
                }
        (5) public int compare(Object o1, Object o2) 返回的值>0 还是 <0
         /**   会影响整个排序结果, 这就充分体现了 接口编程+动态绑定+匿名内部类的综合使用
            将来的底层框架和源码的使用方式，会非常常见*/
        Arrays.sort(arr); // 默认排序方法

三.定制排序

这里运用到了匿名内部类，把匿名内部类当做一个对象更容易理解下面代码

这里代码是现进入sort方法中，在sort方法中含有Comparator方法，根据动态绑定机制，代码会进行匿名内部类中compare方法，return可以进行从大到小或从小到大排序

Integer arr[] = {1, -1, 7, 0, 89};
        //定制排序
        Arrays.sort(arr, new Comparator() {//这里运用了匿名内部类
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
                return i2 - i1;
            }
        });
        System.out.println("===排序后===");
        System.out.println(Arrays.toString(arr));

下面代码是sort中compare方法

 //  匿名内部类的 compare ()
             while (left < right) {
                        int mid = (left + right) >>> 1;
                        if (c.compare(pivot, a[mid]) < 0)
                            right = mid;
                        else
                            left = mid + 1;

四.定制排序练习

结合冒泡排序进行定制排序

public class ArraysSortCustom {
    public static void main(String[] args) {

        int[] arr = {1, -1, 8, 0, 20};
        //bubble01(arr);

        bubble02(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                int i1 = (Integer) o1;
                int i2 = (Integer) o2;
                return i2 - i1;// return i2 - i1;
            }
        });

        System.out.println("==定制排序后的情况==");
        System.out.println(Arrays.toString(arr));

    }

    //传统方法
    //使用冒泡完成排序
//    public static void bubble01(int[] arr) {
//        int temp = 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]) {
//                    temp = arr[j];
//                    arr[j] = arr[j + 1];
//                    arr[j + 1] = temp;
//                }
//            }
//        }
//    }

    //结合冒泡 + 定制
    public static void bubble02(int[] arr, Comparator c) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //数组排序由 c.compare(arr[j], arr[j + 1])返回的值决定
                if (c.compare(arr[j], arr[j + 1]) > 0) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}