Java 数据结构 -- 05.Java 8 数据结构能力接口与能力器接口

书接上文，上一篇对 Java 8 流式处理进行了简单的介绍，本篇将对能力接口与能力器接口进行分析。

在 Java 8 接口概览 中提到，Java 8 提供能力接口与它对应的能力器接口，有的比较器接口又有自己的比较器工具类，这样做的原因是为了屏蔽继承能力接口的不同数据结构实现类的内部结构差异，用能力器接口提供统一的实现能力的方法接口。接下来就对这些能力接口与能力器接口做下简单的介绍

比较能力

能力接口：Comparable

/**
	Java 1.2 开始提供，比较能力接口，实现类具有比较能力，可以进行排序，但只能进行自然排序
	实现这个接口的的 List 或者 数组 对象将自动通过 Collections#sort(List) 和 Arrays#sort(Object[]) 进行比较。官方建议顺序与 equals 方法返回的结果的自然顺序保持一致
**/
public interface Comparable<T> {
   
    /**比较方法，比较当前对象与参数对象的顺序，当前对象小于参数对象时候返回负值，相等时返回 0，大于参数对象时返回 1。**/
    public int compareTo(T o);
}

能力器接口：Comparator

/**与 Comparable 同样是为了某一种类型提供能力，不同的是 Comparable 的实现类是待排序对象本身的类，并且只有一种自然排序方式，而 Comparator 的实现类并不是待排对象类，而是支持这个类的类型排序的一种自定义排序器，意味着对于同一种类型，可以定义复数的排序器**/
@FunctionalInterface
public interface Comparator<T> {
   
    /**接收两个范型参数，如果第一个对象小于第二个对象，则返回负值，如果等于则返回 0，如果大于则返回正值**/
    int compare(T o1, T o2);

    /**针对比较器的 equals 方法**/
    boolean equals(Object obj);

    /**返回当前比较器的反向比较器**/
    default Comparator<T> reversed() {
   
        return Collections.reverseOrder(this);
    }

    /**持续比较方法，用于多个比较器的链式调用，先对于当前 comparator 中的两个参数应用 comapre 方法，如果结果非 0 直接返回，否则再对这两个参数应用 comparator 参数中的 compare 方法，并将两次结果位与后返回**/
    default Comparator<T> thenComparing(Comparator<? super T> other) {
   
        Objects.requireNonNull(other);
        return (Comparator<T> & Serializable) (c1, c2) -> {
   
            int res = compare(c1, c2);
            return (res != 0) ? res : other.compare(c1, c2);
        };
    }

    /**与 Comparator<T> thenComparing(Comparator<? super T> other) 方法类似，多传入一个 Function 参数，先进行 comparing 操作，然后将返回的结果作为一次 thenComparing 操作的参数，最后返回结果**/
    default <U> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {
   
        return thenComparing(comparing(keyExtractor, keyComparator));
    }

    /**与 Comparator<T> thenComparing(Comparator<? super T> other) 方法类似**/
    default <U extends Comparable<? super U>> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor)
    {
   
        return thenComparing(comparing(keyExtractor));
    }

    /**与 Comparator<T> thenComparing(Comparator<? super T> other) 方法类似，接收一个 ToIntFunction 参数**/
    default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {
   
        return thenComparing(comparingInt(keyExtractor));
    }

    /**与 Comparator<T> thenComparing(Comparator<? super T> other) 方法类似，接收一个 ToLongFunction 参数**/
    default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {
   
        return thenComparing(comparingLong(keyExtractor));
    }

    /**与 Comparator<T> thenComparing(Comparator<? super T> other) 方法类似，接收一个 ToDoubleFunction 参数**/
    default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {
   
        return thenComparing(comparingDouble(keyExtractor));
    }

    /**对于 Collections.reverseOrder 方法的封装，不是很明白这个方法存在的意义**/
    public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
   
        return Collections.reverseOrder();
    }

    /**对于 Comparators.NaturalOrderComparator.INSTANCE 方法的封装**/
    @SuppressWarnings("unchecked")
    public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
   
        return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
    }

    /**对 null 比较的友好操作，参数 comparator 中的两个待比较直都为 null，则返回相等，如果都不为 null，那么使用 comparator 参数来定义顺序，如果 comparator 为 null，则返回的 comparator 认为所有非 null 的值相等**/
    public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
   
        return new Comparators.NullComparator<>(true, comparator);
    }

    /**与 nullsFirst 方法完全相同的方法定义。。**/
    public static