java中我们要实现集合元素的比较和排序有两种方法。一种是让集合中的元素去实现Comparable接口，另一种是则是创建一个Comparator比较器（创建比较器就是实现Comparator接口）。第一种我们是在集合内部实现的，因为我们让集合中的元素去实现Comparable接口，我们改变了元素的结构。第二种，我们是在集合外部去实现的。
- 实现Comparable接口，首先我们来看看Comparable接口有什么用，我们为什么要去实现它，这里我觉得最好的说明就是jdk源码中的这段注释。
Compares this object with the specified object for order. Returns a
negative integer, zero, or a positive integer as this object is less
than, equal to, or greater than the specified object.
这段话的主要意思就是说，Comparable接口是为了将此元素与指定元素排序。将返回正数，零，负数，分别表示大于，等于，小于指定元素的含义。
下面就是jdk中Comparable接口的唯一一个方法。
* @param o the object to be compared.
* @return a negative integer, zero, or a positive integer as this object
* is less than, equal to, or greater than the specified object.
*
* @throws NullPointerException if the specified object is null
* @throws ClassCastException if the specified object's type prevents it
* from being compared to this object.
*/
public int compareTo(T o);
当我们使用时只需要实现此接口，并实现CompareTo（）方法。
class Student1 implements Comparable<Student1> {
private int id;
@Override
public int compareTo(Student1 o) {
return o.id>this.id?1:(o.id==this.id?0:-1);
}
}
这里我采用了泛型的写法，在java中使用泛型的好处，我就引用百度百科的这段话加以说明。
泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。
在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率。
- 使用Comparator比较器。其实就是去实现Comparator接口。jdk源码中注释如下。
Compares its two arguments for order. Returns a negative integer,
zero, or a positive integer as the first argument is less than, equal
to, or greater than the second.<p>
让两个元素有序，返回负整数，零，正整数表示第一个参数小于，等于，大于第二个元素。这里说的两个参数，实际上是指Comparator接口中的这个方法的两个参数。
@param o1 the first object to be compared.
* @param o2 the second object to be compared.
* @return a negative integer, zero, or a positive integer as the
* first argument is less than, equal to, or greater than the
* second.
* @throws NullPointerException if an argument is null and this
* comparator does not permit null arguments
* @throws ClassCastException if the arguments' types prevent them from
* being compared by this comparator.
*/
int compare(T o1, T o2);
代码一：
class Student2 implements Comparator<Student2>{
private int id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public int compare(Student2 o1, Student2 o2) {
return o1.id>o2.id?1:(o1.id==o2.id?0:-1);
}
}
代码二：
class MyComparator implements Comparator<Student2>{
@Override
public int compare(Student2 o1, Student2 o2) {
return o1.getId()>o2.getId()?1:(o1.getId()==o2.getId()?0:-1);
}
}
我们经常认为代码一写法和实现Comparable没啥区别，但仔细看来还是有很大区别。首先我们代码一中的方法是compare与compareTo()是不一样，其次我们需要传入两个指定元素。最后虽然我们写在Student2 的类中，但与Student2类没有多大关系，我们还可以在方法中去比较Student1。
代码三
class Student2 implements Comparator {
private int id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Student1 && o2 instanceof Student1) {
return ((Student1) o1).getId() > ((Student1) o2).getId() ? 1
: (((Student1) o1).getId() == ((Student1) o2).getId() ? 0
: -1);
} else if (o1 instanceof Student2 && o2 instanceof Student2) {
return ((Student2) o1).getId() > ((Student2) o2).getId() ? 1
: (((Student2) o1).getId() == ((Student2) o2).getId() ? 0
: -1);
} else
return -1;
}
}
其实Comparator 采用的是策略设计模式，即我会根据传入对象的不同类型，来采用不同的比较策略。当然我们加上泛型之后，也就是只为当前元素服务了。所以如果你的比较器只是为一种元素做比较，你可以按照代码一的写法去写，如果你想做一个通用的比较器，那就按照代码二去写，分离出来，让你的程序的很有可读性。第三种只是为了解决大家的疑惑，开发中应该杜绝这种写法。
