1.Comparable
Comparable是排序接口。此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo()方法被称为它的自然比较方法。
如果一个类实现了Comparable接口，就意味着该类”支持排序”。实现此接口的对象列表（或数组）可以通过Collections.sort()（或Arrays.sort()）进行自动排序。实现此接口的对象可以用作有序映射中的键(比如TreeMap中的键)或者有序集合中的元素（比如TreeSet中的元素），而无需指定比较器。
Comparable接口仅仅只包括一个compareTo(Object obj)函数，如下所示：
public interface Comparable<T>{ public int compareTo(T o);}假设我们通过x.compareTo(y)来比较x和y的大小。若该方法返回正整数，则意味着x > y；若该方法返回负整数，则意味着x < y;若该方法返回0，则意味着x == y。
2.Comparator
Comparator是比较器接口。我们可以将Comparator传递给sort方法（比如Collections.sort()或者Arrays.sort()），从而对一个Collection实现精准排序。还可以通过Comparator来控制某些数据结构（比如TreeSet或者TreeMap）的顺序。
也就是说，我们如果要控制某个类的次序，而该类本身不支持排序（即没有实现Comparable接口），那么我们就可以建立一个“该类的比较器”来进行排序。这个“比较器”只需要实现Comparator接口即可。
Comparator接口包括int compare(T o1,T o2)和equals()两个函数：
public interface Comparator<T>{ int compare(T o1, T o2); boolean equals(Object obj);}要知道的是：
（1）若一个类实现了Comparator接口，它一定要实现compare(T o1,T o2)方法，但可以不实现equals(Object obj)方法。为什么呢？因为任何类都默认继承于Object类，在Object类中实现了equals()方法，所以相当于其他所有的类都已经实现了equals()方法。（2）int compare(T o1,T o2)方法是比较o1和o2的大小，该方法返回正整数，意味着o1比o2大；返回负整数，意味着o1比o2小；返回0，意味着o1与o2相等。3.Comparable与Comparator的比较
Comparable是排序接口；若一个类实现了Comparable接口，就意味着“该类支持排序” 而Comparator是比较器；我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。
我们不难发现：Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。
下面我们举一个例子。
首先我们自定义一个People类，如下：
public class People implements Comparable<People>{ PRivate String name; private int age; public String getName() { return name; } public int getAge() { return age; } public People(String name, int age) { super(); this.name = name; this.age = age; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } /** * 两个People对象的name属性和age属性都相等，就认为两个对象相等 */ @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; People other = (People) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } @Override public String toString() { return name + "---" + age; } /** * 默认的排序，按照name属性排序 */ @Override public int compareTo(People o) { return this.name.compareTo(o.name); }}People类有name和age两个属性，重写了equals()和hashCode()方法，并且重写了toString()方法。最重要的是，People类实现了Comparable接口，并重写了compareTo(People o)方法，该方法让People类默认支持排序，并且排序的依据是name属性的字母序。
接着，我们可以在主方法中测试：
public class Test { public static void main(String[] args) { System.out.println("----------ArrayList------------"); ArrayList<People> array = new ArrayList<>(); array.add(new People("ddd",20)); array.add(new People("aaa",30)); array.add(new People("ccc",10)); array.add(new People("bbb",40)); System.out.println("原始序列："+array); // 对array进行排序，按照People类默认的排序方法，即按照name属性进行升序排列 Collections.sort(array); System.out.println("Name升序："+array); }}程序输出：
原始序列：[ddd---20, aaa---30, ccc---10, bbb---40]Name升序：[aaa---30, bbb---40, ccc---10, ddd---20]可以看到，我们采用ArrayList保存了4个People类对象，并调用Collections.sotr()方法对该List进行排序，排序之前是原始序列；排序之后，按照People类中的定义，默认按照name属性的升序排列。
除此之外，我们可以自定义Comparator类对象，使之按照age属性进行排列。
比如，我们可以按照age属性的升序排列：
public class AscAgeComparator implements Comparator<People> { @Override public int compare(People o1, People o2) { return o1.getAge() - o2.getAge(); }}自定义AscAgeComparator类，实现Comparator接口，并重写compare(People o1, People o2)方法，该方法按照age属性进行升序排列。
或者我们也可以按照age属性进行降序排列，如下定义DescAgeComparator:
public class DescAgeComparator implements Comparator<People> { @Override public int compare(People o1, People o2) { return o2.getAge() - o1.getAge(); }}
这时候我们在调用Collections.sort()方法时，也可以给该方法传递一个Comparator对象，使之按照该对象自定义的排序方式进行排序：
public class Test { public static void main(String[] args) { System.out.println("----------ArrayList------------"); ArrayList<People> array = new ArrayList<>(); array.add(new People("ddd",20)); array.add(new People("aaa",30)); array.add(new People("ccc",10)); array.add(new People("bbb",40)); System.out.println("原始序列："+array); // 通过AscAgeComparator比较器进行排序，根据age升序排列 Collections.sort(array, new AscAgeComparator()); System.out.println("Age升序："+array); // 通过DescAgeComparator比较器进行排序，根据age降序排列 Collections.sort(array, new DescAgeComparator()); System.out.println("Age降序："+array); }}程序输出：
原始序列：[ddd---20, aaa---30, ccc---10, bbb---40]Age升序：[ccc---10, ddd---20, aaa---30, bbb---40]Age降序：[bbb---40, aaa---30, ddd---20, ccc---10]4.Comparator的应用之实现Map按照value值进行排序
这里补充一个Comparator的一个很实用的应用例子。
Map本身并不支持按照value值进行排序，TreeMap实现的也是按照key值进行排序，那么如何实现Map按照value值进行排序呢？这时候我们可以将该Map转换成List<Map.Entry<T,T>>，也就是把Map中每一个Entry键值对保存在List中，再自定义Comparator，对该List进行排序即可。
比如，我们再自定义People类如下：
public class People { private int age; private String name; public int getAge() { return age; } public String getName() { return name; } public People( String name,int age) { super(); this.age = age; this.name = name; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; People other = (People) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } @Override public String toString() { return name + "---" + age; }}这次，People类并没有实现Comparable接口，也就是说People类不支持排序。
我们将People类对象作为value值保存在Map中，做如下测试：
public class Test { public static void main(String[] args) { HashMap<String, People> hm = new HashMap<>(); hm.put("1", new People("ddd",20)); hm.put("2", new People("ccc",40)); hm.put("3", new People("aaa",30)); hm.put("4", new People("bbb",10)); System.out.println("排序之前："); hm.forEach((key,value) -> System.out.println(key + " " + value)); // 将Map中的每一个键值对转化为Entry对象，保存在List中 List<Entry<String, People>> list = new ArrayList<>(hm.entrySet()); // 自定义Comparator，按照People对象的年龄升序进行排序 Comparator<Map.Entry<String, People>> valueComparator = new Comparator<Map.Entry<String,People>>() { @Override public int compare(Entry<String, People> o1, Entry<String, People> o2) { return o1.getValue().getAge() - o2.getValue().getAge(); } }; // 排序，比较器为我们自定义的valueComparator Collections.sort(list, valueComparator); System.out.println("排序之后："); //java8中支持的遍历输出： list.forEach((item -> System.out.println(item.getKey() + " " + item.getValue()))); }}最后我们按照People对象的age属性进行升序排列，程序输出：
排序之前：1 ddd---202 ccc---403 aaa---304 bbb---10排序之后：4 bbb---101 ddd---203 aaa---302 ccc---40
