java Comparable与Comparator的区别

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

让两个元素有序，返回负整数，零，正整数表示第一个参数小于，等于，大于第二个元素。这里说的两个参数，实际上是指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{
    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{

    @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 采用的是策略设计模式，即我会根据传入对象的不同类型，来采用不同的比较策略。当然我们加上泛型之后，也就是只为当前元素服务了。所以如果你的比较器只是为一种元素做比较，你可以按照代码一的写法去写，如果你想做一个通用的比较器，那就按照代码二去写，分离出来，让你的程序的很有可读性。第三种只是为了解决大家的疑惑，开发中应该杜绝这种写法。