接口 Comparator 实现定制排序|接口编程+动态绑定+匿名内部类|向下转型+自动拆箱。。。

Arrays排序源码解读

挺难的,说实话没懂。。。。。。

package eunm.Throws;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class WrapperType {
    public static void main(String[] args) {
        Integer arr[] = {1237, 1, 45, 11, 56, 2};
        //1. 可以直接使用冒泡排序，也可以直接使用Arrays提供的sort方法排序 Arrays.sort(arr);
        //2. 因为数组是引用类型，所以通过sort排序后，会直接影响到实参arr
        /*
        3. sort重载的，也可以通过传入一个接口 Comparator 实现定制排序
        4. 调用定制排序时，传入两个参数(1) 排序的数组arr (2) 实现了Comparator接口的匿名内部类 ，要求实现compare方法
        5.这里体现了接口编程的方式，看源码，就明白
        源码分析
        (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(0bject o1, 0bject o2) 返回的值>0还是<0会影响整个排序结果，
        这就充分体现了接口编程+动态绑定+閣名内部类的综合使用
         */
        //定制排序
        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));
    }
}

md上节课白看了，直接到这多香

package eunm.Throws.Arrays;

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

public class ArraysSortCustom {
    public static void main(String[] args) {
        int[] arr = {21, 1, 3, 22, 34, 2, 5};
        bubble1(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //向下转型+自动拆箱
                /*
                拆箱就是将包装类型对象转换为其对应的基本数据类型，
                而装箱则是将基本数据类型转换为相应的包装类型对象。
                Integer integer = Integer.valueOf();
                int integer = integer.intValue();
                自动装箱是通过 Integer.valueOf() 完成的；自动拆箱是通过 Integer.intValue() 完成的。
                 */
                int i1 = (Integer) o1;
                int i2 = (Integer) o2;
                return i1 - i2;//or i2-i1这里决定下面c.compare(arr[j],arr[j+1])返回的值
            }
        });
        System.out.println("排序后");
        System.out.println(Arrays.toString(arr));
    }

    //结合冒泡+定制
    public static void bubble1(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;
                }
            }
        }
    }
}

我看到这里一脸懵逼，然后直接去网上查了一下什么是自动拆箱自动装箱，没看大懂，明天再研究一下。

https://javabetter.cn/basic-extra-meal/box.html#%E6%80%BB%E7%BB%93

 bubble1(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //向下转型+自动拆箱
                /*
                拆箱就是将包装类型对象转换为其对应的基本数据类型，
                而装箱则是将基本数据类型转换为相应的包装类型对象。
                Integer integer = Integer.valueOf();
                int integer = integer.intValue();
                自动装箱是通过 Integer.valueOf() 完成的；自动拆箱是通过 Integer.intValue() 完成的。
                 */
                int i1 = (Integer) o1;
                int i2 = (Integer) o2;
                return i1 - i2;//or i2-i1这里决定下面c.compare(arr[j],arr[j+1])返回的值
            }
        });