java comparator的个人理解

前言

我是看了别人的资料，进行自我理解的整理，可能没有讲的那么详细。多多包涵。

推荐：java comparator 升序、降序、倒序从源码角度理解，讲的很清楚。

Demo

List<Integer> list = Arrays.asList(5,2,4,8,9,10,1,3);

Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        if(o1 < o2) {
            System.out.println("o1="+o1 + ",o2=" + o2 + "   "+ "return = -1");
            return -1;
        } else if (o1 > o2) {
            System.out.println("o1="+o1 + ",o2=" + o2 + "   "+ "return = 1");
            return 1;
        } else {
            System.out.println("o1="+o1 + ",o2=" + o2 + "   "+ "return = 0");
            return 0;
        }
    }
});

源码分析

public static <T> void sort(List<T> list, Comparator<? super T> c) {
    list.sort(c);
}

    public static <T> void sort(T[] a, Comparator<? super T> c) {
        //没有实现比较器的情况
        if (c == null) {
            sort(a);
        } else { //实现了比较器
            //弃用
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, c);
            else
                TimSort.sort(a, 0, a.length, c, null, 0, 0);
        }
    }

    /*
     * @param a :要排序的数组
     * @param lo :第一个元素下标
     * @param hi :最后一个元素下标
     * @param c :实现的比较器
     * @param work :工作区数组
     * @param workBase:工作数组可用的空间来源
     * @param workLen:工作数组可用的大小
     * @since 1.8
     */
	static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
                         T[] work, int workBase, int workLen) {
        assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;

        int nRemaining  = hi - lo;
        if (nRemaining < 2)
            return;  // Arrays of size 0 and 1 are always sorted

        // 如果数组元素数量 < 32，就进行 mini-TimSort
        if (nRemaining < MIN_MERGE) {
            //initRunLen是返回第一次比较情况的最大下标
            int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
            //剩余没排序的部分进行二分排序进行插入
            binarySort(a, lo, hi, lo + initRunLen, c);
            return;
        }

        /**
         * March over the array once, left to right, finding natural runs,
         * extending short natural runs to minRun elements, and merging runs
         * to maintain stack invariant.
         */
        TimSort<T> ts = new TimSort<>(a, c, work, workBase, workLen);
        int minRun = minRunLength(nRemaining);
        do {
            // Identify next run
            int runLen = countRunAndMakeAscending(a, lo, hi, c);

            // If run is short, extend to min(minRun, nRemaining)
            if (runLen < minRun) {
                int force = nRemaining <= minRun ? nRemaining : minRun;
                binarySort(a, lo, lo + force, lo + runLen, c);
                runLen = force;
            }

            // Push run onto pending-run stack, and maybe merge
            ts.pushRun(lo, runLen);
            ts.mergeCollapse();

            // Advance to find next run
            lo += runLen;
            nRemaining -= runLen;
        } while (nRemaining != 0);

        // Merge all remaining runs to complete sort
        assert lo == hi;
        ts.mergeForceCollapse();
        assert ts.stackSize == 1;
    }

这个方法返回一个数值，这个数值保证前面的元素是升序的

    
	private static <T> int countRunAndMakeAscending(T[] a, int lo, int hi,
                                                    Comparator<? super T> c) {
        assert lo < hi;
        int runHi = lo + 1; 
        if (runHi == hi)
            return 1;

        // Find end of run, and reverse range if descending
        // 第一次调用时，a[0] 和 a[1] 的大小顺序决定进入哪一个while循环
        // 而返回的runHi++，是维持第一次的比较情况的最大下标值
        // reverseRange(a, lo, runHi);  反转a[] 中 下标为lo ~ runHi 的元素
        /*
        我们原数组: 5,2,4,8,9,10,1,3
        比如有可能 a[1] > a[0]  return -1,也有可能是 a[1] < a[0] 返回 -1
        假设 a[1] < a[0] 返回 -1======> 也就是 o1 < o2的情况 返回 -1 
        进入的while循环到，找到能维持 o1 < o2 的比较情况的最大下标.
        if 条件句：第一次 o1 = a[1] = 2  o2 = a[0] = 5   runHi = 1
        if 结束后 runHi1 = 2;
        进入while循环先判断  o1 = a[2] = 4, o2 = a[1] = 2, while循环结束,
        反转元素  a[] = 2,5,4,8,9,10,1,3
        */ 
        //最后整个方法返回 runHi  = 2,这个数值是保持的 o1 < o2 返回 -1 这种比较情况的最大下标
        if (c.compare(a[runHi++], a[lo]) < 0) { // Descending
            while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
                runHi++;
            reverseRange(a, lo, runHi);
        } else {                              // Ascending
            while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)
                runHi++;
        }

        return runHi - lo;
    }
	
	//交换元素
    private static void reverseRange(Object[] a, int lo, int hi) {
        hi--;
        while (lo < hi) {
            Object t = a[lo];
            a[lo++] = a[hi];
            a[hi--] = t;
        }
    }

官方Comparator默认是升序，是基于

o1 < o2  return -1
o1 == o2  return 0
o1 > o2 return 1

Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        if(o1 < o2) {
            return -1;
        } else if (o1 > o2) {
            return 1;
        } else {
            return 0;
        }
    }
});

结合我们上面的分析

原数组 ：5,2,4,8,9,10,1,3
第一次比较情况  o1 = 2, o2 5  返回 -1  // 即两个元素，原数组中前者 > 后者 ，
我们第一次比较就返回值 < 0, 得到了 initRunLen后，就会交换数组中 [0,initRunLen-1]的元素  //2,5,4,8,9,10,1,3
剩余的其他元素就会通过 其他方法进行插入，保持 2 < 5 的排序。
    
 如果第一次比较情况返回值 >= 0，就仅仅只会得到 initRunLen，而不会交换。说明前两个元素已经满足了想要的排序，剩余的其他数组元素要经过二分排序进行插入，完成整个数组的排序。

总结：

//官方默认的升序
o1 < o2  return -1
o1 == o2  return 0
o1 > o2 return 1
    

//降序
o1 < o2  return 1
o1 == o2  return 0
o1 > o2 return -1

1.如果整个比较都返回0，会怎么样

​ 会发现数组顺序没有发生改变

​ 仔细观察也会发现，都返回1 也是不排序的

// Find end of run, and reverse range if descending
        if (c.compare(a[runHi++], a[lo]) < 0) { // Descending
            while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
                runHi++;
            reverseRange(a, lo, runHi);
        } else {
        //走这个循环                              
            while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)
                runHi++;
        }

2.如果比较都返回-1，会怎么样

​ 得到runHi == a.length - 1;，然后调用 reverseRange ，整个数组都会倒序，但是不排序。

// Find end of run, and reverse range if descending
		//走这个循环
        if (c.compare(a[runHi++], a[lo]) < 0) { // Descending
            while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
                runHi++;
            reverseRange(a, lo, runHi);
        } else {
                                      
            while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)
                runHi++;
        }

---

欢迎交流，欢迎交流