comparator接口实现时，只需要实现 int compare(T o1, T o2)方法？

从Comparator接口的源码，可以看到Comparator接口中的方法有三类：

1 普通接口方法

2 default方法

3 static方法

其中default方法和static方法 是java8新加的特性，default方法提供了方法实现，不强制接口实现类实现。static相较于default方法可以在直接用“接口名.方法名”调用。

那么，Comparator接口的实现类应该实现其中的comparator方法和equals方法。

但是，由于接口（接口可以看做一种特殊的类）以及该接口的实现类都默认继承了Object类，在java代码编译为字节码的过程后，实际上equals方法都已经被实现，编译器也就不会认为Comparator接口的equals方法没有实现。

另外，一般来讲“接口是不能继承类的”，实际严格来说是接口不能显式地继承类，并且不是想类的继承那样逻辑，接口会自动声明public abstract的方法与Object中的public方法一一对应。

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<T> {

int compare(T o1, T o2);

boolean equals(Object obj);

default Comparator<T> reversed() {

return Collections.reverseOrder(this);

}

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);

};

}

default <U> Comparator<T> thenComparing(

Function<? super T, ? extends U> keyExtractor,

Comparator<? super U> keyComparator)

{

return thenComparing(comparing(keyExtractor, keyComparator));

}

default <U extends Comparable<? super U>> Comparator<T> thenComparing(

Function<? super T, ? extends U> keyExtractor)

{

return thenComparing(comparing(keyExtractor));

}

default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {

return thenComparing(comparingInt(keyExtractor));

}

default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {

return thenComparing(comparingLong(keyExtractor));

}

default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {

return thenComparing(comparingDouble(keyExtractor));

}

public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {

return Collections.reverseOrder();

}

@SuppressWarnings("unchecked")

public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {

return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;

}

public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {

return new Comparators.NullComparator<>(true, comparator);

}

public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {

return new Comparators.NullComparator<>(false, comparator);

}

public static <T, U> Comparator<T> comparing(

Function<? super T, ? extends U> keyExtractor,

Comparator<? super U> keyComparator)

{

Objects.requireNonNull(keyExtractor);

Objects.requireNonNull(keyComparator);

return (Comparator<T> & Serializable)

(c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),

keyExtractor.apply(c2));

}

public static <T, U extends Comparable<? super U>> Comparator<T> comparing(

Function<? super T, ? extends U> keyExtractor)

{

Objects.requireNonNull(keyExtractor);

return (Comparator<T> & Serializable)

(c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));

}

public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {

Objects.requireNonNull(keyExtractor);

return (Comparator<T> & Serializable)

(c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));

}

public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) {

Objects.requireNonNull(keyExtractor);

return (Comparator<T> & Serializable)

(c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));

}

public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor) {

Objects.requireNonNull(keyExtractor);

return (Comparator<T> & Serializable)

(c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));

}

}