一、概述
Java中的排序是由Comparable和Comparator这两个接口来供应的。
Comparable示意可被排序的，完成该接口的类的对象自动具有排序功用。
Comparator则示意一个比较器，完成了该接口的的类的对象是一个针对目的类的对象定义的比较器，平常状况，这个比较器将作为一个参数举行通报。
二、Comparable
Comparable的中文意义就是可被排序的，代表自身支撑排序功用。只需我们的类完成了这个接口，那末这个类的对象就会自动具有了可被排序的才能。而且这个排序被称为类的天然递次。这个类的对象的列表能够被Collections.sort和Arrays.sort来实行排序。同时这个类的实例具有作为sorted map的key和sorted set的元素的资历。
假如a和b都是完成了Comparable接口的类C的实例，那末只要当a.compareTo(b)的效果与a.equals(b)的效果一致时，才称类C的天然递次与equals一致。强烈建议将类的天然递次和equals的效果保持一致，由于假如不一致的话，由该类对象为键的sorted map和由该类对象为元素的sorted set的行动将会变得很奇异。
比方关于一个完成了Comparable接口的元素的有序鸠合sorted set而言，假如a.equals(b)效果为false，而且a.compareTo(b)==0，则第二个元素的增加操纵将会失利，由于在sorted set看来，两者在排序上是一致的，它不报保留反复的元素。
事实上，Java中的类基础都是天然递次与equals一致的，除了BigDecimal，由于BigDecimal中的天然递次和值雷同但精度差别的元素（比方4和4.00）的equals均一致。
源码剖析
public interface Comparable<T> {
public int compareTo(T o);
}
从源码中能够看到，该接口只要一个笼统要领compareTo，这个要领重要就是为了定义我们的类所要排序的体式格局。compareTo要领用于比较当前元素a与指定元素b，效果为int值，假如a > b，int>0；假如a=b，int=0；假如a<b，int<0。
三、Comparator
Comparator中文译为比较器，它能够作为一个参数通报到Collections.sort和Arrays.sort要领来指定某个类对象的排序体式格局。同时它也能为sorted set和sorted map指定排序体式格局。
同Comparable相似，指定比较器的时刻平常也要保证比较的效果与equals效果一致，不一致的话，对应的sorted set和sorted map的行动同样会变得奇异。
引荐完成的比较器类同时完成java.io.Serializable接口，以具有序列化才能，由于它可能会被用作序列化的数据结构（TreeSet、TreeMap）的排序要领。
源码剖析
@FunctionalInterface
public interface Comparator<T> {
// 唯一的笼统要领，用于定义比较体式格局（即排序体式格局）
// o1>o2，返回1；o1=o2，返回0；o1<o2，返回-1
int compare(T o1, T o2);
boolean equals(Object obj);
// 1.8新增的默许要领：用于反序分列
default Comparator<T> reversed() {
return Collections.reverseOrder(this);
}
// 1.8新增的默许要领：用于构建一个次级比较器，当前比较器比较效果为0，则运用次级比较器比较
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);
};
}
// 1.8新增默许要领：指定次级比较器的
// keyExtractor示意键提取器，定义提取体式格局
// keyComparator示意键比较器，定义比较体式格局
default <U> Comparator<T> thenComparing(
Function<? super T, ? extends U> keyExtractor,
Comparator<? super U> keyComparator)
{
return thenComparing(comparing(keyExtractor, keyComparator));
}
// 1.8新增默许要领：用于实行键的比较，采纳的是由键对象内置的比较体式格局
default <U extends Comparable<? super U>> Comparator<T> thenComparing(
Function<? super T, ? extends U> keyExtractor)
{
return thenComparing(comparing(keyExtractor));
}
// 1.8新增默许要领：用于比较实行int范例的键的比较
default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {
return thenComparing(comparingInt(keyExtractor));
}
// 1.8新增默许要领：用于比较实行long范例的键的比较
default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {
return thenComparing(comparingLong(keyExtractor));
}
// 1.8新增默许要领：用于比较实行double范例的键的比较
default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {
return thenComparing(comparingDouble(keyExtractor));
}
// 1.8新增静态要领：用于获得一个相反的排序的比较器，这里针对的是内置的排序体式格局（即继续Comparable）
public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
return Collections.reverseOrder();
}
// 1.8新增静态要领：用于获得一个完成了Comparable接口的类的比较体式格局的比较器
// 简言之就是将Comparable定义的比较体式格局运用Comparator完成
@SuppressWarnings("unchecked")
public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
}
// 1.8新增静态要领：获得一个null亲和的比较器，null小于非null，两个null相称，假如全不是null,
// 则运用指定的比较器比较，若未指定比较器，则非null悉数相称返回0
public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
return new Comparators.NullComparator<>(true, comparator);
}
// 1.8新增静态要领：获得一个null亲和的比较器，null大于非null，两个null相称，假如全不是null,
// 则运用指定的比较器比较，若未指定比较器，则非null悉数相称返回0
public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
return new Comparators.NullComparator<>(false, comparator);
}
// 1.8新增静态要领：运用指定的键比较器用于实行键的比较
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));
}
// 1.8新增静态要领：实行键比较，采纳内置比较体式格局，key的类必需完成Comparable
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));
}
// 1.8新增静态要领：用于int范例键的比较
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));
}
// 1.8新增静态要领：用于long范例键的比较
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));
}
// 1.8新增静态要领：用于double范例键的比较
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));
}
}
老版本的Comparator中只需两个要领，就是前两个要领，背面的一切默许要领均为1.8新增的要领，采纳的是1.8新增的功用：接口可增加默许要领。即使具有云云多要领，该接口照样函数式接口，compare用于定义比较体式格局。
四、两者比较
Comparable能够看作是内部比较器，Comparator能够看作是外部比较器。
一个类，能够经由过程完成Comparable接口来自带有序性，也能够经由过程分外指定Comparator来附加有序性。
两者的作用实际上是一致的，所以不要混用。
我们看个例子吧：
起首定义个模子：User
public class User implements Serializable, Comparable<User> {
private static final long serialVersionUID = 1L;
private int age;
private String name;
public User (){}
public User (int age, String name){
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int compareTo(User o) {
return this.age - o.age;
}
@Override
public String toString() {
return "[user={age=" + age + ",name=" + name + "}]";
}
}
在定义一个Comparator完成类MyComparator
public class MyComparator implements Comparator<User> {
@Override
public int compare(User o1, User o2) {
return o1.getName().charAt(0)-o2.getName().charAt(0);
}
}
末了是测试类：Main
public class Main {
public static void main(String[] args) {
User u1 = new User(12, "xiaohua");
User u2 = new User(10, "abc");
User u3 = new User(15,"ccc");
User[] users = {u1,u2,u3};
System.out.print("数组排序前：");
printArray(users);
System.out.println();
Arrays.sort(users);
System.out.print("数组排序1后：");
printArray(users);
System.out.println();
Arrays.sort(users, new MyComparator());
System.out.print("数组排序2后：");
printArray(users);
System.out.println();
Arrays.sort(users, Comparator.reverseOrder());// 针对内置的排序举行颠倒
System.out.print("数组排序3后：");
printArray(users);
}
public static void printArray (User[] users) {
for (User user:users) {
System.out.print(user.toString());
}
}
}
运转效果为：
数组排序前：[user={age=12,name=xiaohua}][user={age=10,name=abc}][user={age=15,name=ccc}]
数组排序1后：[user={age=10,name=abc}][user={age=12,name=xiaohua}][user={age=15,name=ccc}]
数组排序2后：[user={age=10,name=abc}][user={age=15,name=ccc}][user={age=12,name=xiaohua}]
数组排序3后：[user={age=15,name=ccc}][user={age=12,name=xiaohua}][user={age=10,name=abc}]
经由过程上面的例子我们有一个结论，那就是两种体式格局定义排序的优先级，显著Comparator比较器要优先于内部排序Comparable。
五、总结
Comparable为可排序的，完成该接口的类的对象自动具有可排序功用。
Comparator为比较器，完成该接口能够定义一个针对某个类的排序体式格局。
Comparator与Comparable同时存在的状况下，前者优先级高。
以上就是Java中Comparable和Comparator的对照引见（代码示例）的细致内容，更多请关注ki4网别的相干文章！
