Java Comparator源码总结 Comparator源码注释翻译和解析中英文对照版

版本
JDK8(JDK1.8)

Comparator接口重点
1.Comparator接口是一个函数式接口，里面只有一个虚方法compare(T o1, T o2)，该接口表示一个比较器，而实现Comparable接口则表示其实现类是可比较的，Comparable接口的虚方法是compareTo(T o)
Comparable接口源码可以看我这篇位置 Comparable

2.compare(T o1, T o2) 返回值大于0，表示 o1 - o2 > 0，若o1,o2相等，则compare(T o1, T o2) 返回0

3.Comparator接口方法
注：then开头比较器都是二次比较器，在第一次调用this.compare(T o1, T o2)两者相等，才会使用一个新的比较器来区分两者顺序，如果第一次都不相等，则不会调用后续比较器

Comparator接口源码

package java.util;

import java.io.Serializable;
import java.util.function.Function;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.function.ToDoubleFunction;
import java.util.Comparators;


@FunctionalInterface
public interface Comparator {
    
    int compare(T o1, T o2);

    
    boolean equals(Object obj);

    
    default Comparator reversed() {
        return Collections.reverseOrder(this);
    }

    
    default Comparator thenComparing(Comparator other) {
        Objects.requireNonNull(other);
        return (Comparator & Serializable) (c1, c2) -> {
            int res = compare(c1, c2);
            return (res != 0) ? res : other.compare(c1, c2);
        };
    }

    
    default  Comparator thenComparing(
            Function keyExtractor,
            Comparator keyComparator)
    {
        return thenComparing(comparing(keyExtractor, keyComparator));
    }

    
    default > Comparator thenComparing(
            Function keyExtractor)
    {
        return thenComparing(comparing(keyExtractor));
    }

    
    default Comparator thenComparingInt(ToIntFunction keyExtractor) {
        return thenComparing(comparingInt(keyExtractor));
    }

    
    default Comparator thenComparingLong(ToLongFunction keyExtractor) {
        return thenComparing(comparingLong(keyExtractor));
    }

    
    default Comparator thenComparingDouble(ToDoubleFunction keyExtractor) {
        return thenComparing(comparingDouble(keyExtractor));
    }

    
    public static > Comparator reverseOrder() {
        return Collections.reverseOrder();
    }

    
    @SuppressWarnings("unchecked")
    public static > Comparator naturalOrder() {
        return (Comparator) Comparators.NaturalOrderComparator.INSTANCE;
    }

    
    public static  Comparator nullsFirst(Comparator comparator) {
        return new Comparators.NullComparator<>(true, comparator);
    }

    
    public static  Comparator nullsLast(Comparator comparator) {
        return new Comparators.NullComparator<>(false, comparator);
    }

    
    public static  Comparator comparing(
            Function keyExtractor,
            Comparator keyComparator)
    {
        Objects.requireNonNull(keyExtractor);
        Objects.requireNonNull(keyComparator);
        return (Comparator & Serializable)
            (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                              keyExtractor.apply(c2));
    }

    
    public static > Comparator comparing(
            Function keyExtractor)
    {
        Objects.requireNonNull(keyExtractor);
        return (Comparator & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }

    
    public static  Comparator comparingInt(ToIntFunction keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator & Serializable)
            (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
    }

    
    public static  Comparator comparingLong(ToLongFunction keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator & Serializable)
            (c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));
    }

    
    public static Comparator comparingDouble(ToDoubleFunction keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator & Serializable)
            (c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
    }
}