似懂非懂 Comparable和 Comparator

在java中提供了两种排序方式：Comparable和 Comparator，它们两个看起来很是的类似，在不是很了解的状况下不知道如何使用，什么状况下使用哪一个进行排序，接下来就看下它们的一个区别和使用方式：

Comparable

首先看下 Comparable，Comparable 它能够当作是一个排序接口，一个类实现了该接口，就表示该类自己具备排序的功能，若是对该类的集合或者数组进行排序，则可使用 Collections.sort() 和 Arrays.sort() 进行排序而不用再指定额外的比较器；

此外，实现了该接口的类，也能够做为 SortedMap 和 SortedSet 的 key 也不用再指定额外的比较器， 可是，若是须要把实现了该接口的类看成 SortedMap 的 Key 或者 放入到  SortedSet 中，须要保证 e1.compareTo(e2) == 0 和 e1.equals(e2) 相等，

可是有一点须要注意的是：由于 e.equal(null) 会返回false，因此，当咱们须要比较的对象为 null 的时候，应该抛出一个 空指针异常。

接下来看下 Comparable 接口的方法，该接口下只有一个方法：

public int compareTo(T o);

该接口返回一个 int 类型，有三种状况：

若 e1 > e2 则 e1.compateTo(e2) > 0，返回正数

若 e1 = e2 则 e1.compateTo(e2) = 0，返回0

若 e1 < e2 则 e1.compateTo(e2) < 0，返回负数

接下来看下如何使用：

首先定义一个类实现该接口，以后重写 compareTo() 方法，通常也须要重写 equal()  和 hashcode() 方法：

@Getter
@Setter
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class User implements Comparable<User> {

    private String name;

    private int age;

    private String job;

    @Override
    public int compareTo(User o) {
        return getName().compareTo(o.getName());
    }

    @Override
    public int hashCode() {
        return getName().hashCode() * 31 + getAge();
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj){
            return true;
        }
        if (! (obj instanceof User)){
            return false;
        }
        User u = (User)obj;
        return (getName().equals(u.getName())) && (getAge() == u.getAge()) && (getJob().equals(u.getJob()));
    }
}

接下来就能够对 该类进行排序了：

首先建立该对象的一个集合：

User u1 = new User("zhangsan", 28, "C++");
        User u2 = new User("zhangsan", 28, "C++");
        User u3 = new User("wangwu", 22, "C");
        User u4 = new User("xiaoliu", 26, "Python");
        User u5 = new User("jiqjiq", 11, "Go");

        System.out.println(u1.equals(u2)); // true
        System.out.println(u1.compareTo(u2) == 0); // true

        List<User> users = Lists.newArrayList(u1, u2, u3, u4, u5);

以后，可使用   Collections.sort() 和 Arrays.sort() 进行排序，而不用再指定额外的比较器了：

System.out.println("排序以前...........");
        users.forEach((u) -> System.out.println(u));
        
        // 排序
        Collections.sort(users);

        System.out.println("排序以后...");
        users.forEach((u) -> System.out.println(u));

结果：
排序以前...........
User(name=zhangsan, age=28, job=C++)
User(name=zhangsan, age=28, job=C++)
User(name=wangwu, age=22, job=C)
User(name=xiaoliu, age=26, job=Python)
User(name=jiqjiq, age=11, job=Go)
排序以后...
User(name=jiqjiq, age=11, job=Go)
User(name=wangwu, age=22, job=C)
User(name=xiaoliu, age=26, job=Python)
User(name=zhangsan, age=28, job=C++)
User(name=zhangsan, age=28, job=C++)

以后，还能够把这些对象放入到 SortedSet 中，就会天然对这些对象进行排序：

TreeSet<User> treeSet = new TreeSet<>(users);

treeSet.forEach((user -> System.out.println(user)));

结果：

User(name=jiqjiq, age=11, job=Go)
User(name=wangwu, age=22, job=C)
User(name=xiaoliu, age=26, job=Python)
User(name=zhangsan, age=28, job=C++)

由于 Set 中没有重复元素，全部会过滤掉重复的元素。

在java的核心类库中，一些类已经实现该接口，因此能够直接对应它们进行排序，如 String , Integer 等：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence 

public final class Integer extends Number implements Comparable<Integer> 


List<String> strings = Lists.newArrayList("c", "e", "a", "b", "d");
Collections.sort(strings);

List<Integer> integers = Lists.newArrayList(3, 2, 4, 1, 5);
Collections.sort(integers);

Comparator

Comparator 能够把它当作是一个比较器接口，它是一个比较器，实现该接口的类自己没有比较的功能，只是用它去对其余的元素进行排序：

Comparator 接口有两个方法：

int compare(T o1, T o2);
boolean equals(Object obj);

还有一些默认的方法，都是一些 java8 中的方法，

自定义一个比较器：

public class UserSortByName implements Comparator<User1> {

    @Override
    public int compare(User1 o1, User1 o2) {
        return o1.getName().compareTo(o2.getName());
    }
}

以后就可使用该自定义的比较器对集合进行排序：

List<User1> users1 = Lists.newArrayList(u11, u21, u31, u41, u51);
 Collections.sort(users1, new UserSortByName());

固然，也能够不用自定义一个比较器，直接使用匿名类便可，以下：

// 排序
        Collections.sort(users1, new Comparator<User1>() {
            @Override
            public int compare(User1 o1, User1 o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });

        // lambda 表达式的写法：

        Collections.sort(users1, Comparator.comparing(User1::getName));


        // 添加到 SortedSet 中
        TreeSet<User1> treeSet1 = new TreeSet<>(new Comparator<User1>() {
            @Override
            public int compare(User1 o1, User1 o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });
        treeSet1.addAll(users1);
        
        // lambda 表达式写法
        TreeSet<User1> treeSet2 = new TreeSet<>(Comparator.comparing(User1::getName));
        treeSet2.addAll(users1);

总结：

Comparable 它是一个排序接口，实现该接口的类自己具备排序的功能，能够直接使用 Collections.sort() 和 Arrays.sort() 进行排序而不用再指定额外的比较器；也能够直接放入到 SortedSet 和 SortedMap 中的保证其有序；

Comparator 它是一个比较器，实现该接口的类只能用其对其余对象进行排序；

Comparable 更多的像一个内部比较器，而 Comparator  更多的像一个外部比较器