Java中Comparator与Comparable的使用

先看下两个接口区别

public interface Comparable<T> {
    public int compareTo(T o);
}

public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
}

用例子说话

	ArrayList<Integer> integerList = new ArrayList<>();
        integerList.add(3);
        integerList.add(1);
        integerList.add(2);

        Collections.sort(integerList);
        System.out.println("\n***************纯数字排序Collections.sort(integerList)***************");
        System.out.println("默认排序\n" + integerList);
        Collections.reverse(integerList);
        System.out.println("倒序排序\n" + integerList);

        System.out.println("\n***************纯字母排序Collections.sort(stringList)***************");
        ArrayList<String> stringList = new ArrayList<>();
        stringList.add("c");
        stringList.add("a");
        stringList.add("b");
        Collections.sort(stringList);
        System.out.println("默认排序\n" + stringList);
        Collections.reverse(stringList);
        System.out.println("倒序排序\n" + stringList);

        System.out.println("\n***************自定义排序***************");
        ArrayList<User> userList = new ArrayList<>();
        userList.add(new User("aa",18));
        userList.add(new User("aa",17));
        userList.add(new User("ab",19));
        System.out.println("按名字排序(升序)");
        //可以直接用匿名类，也可以单独写一个实现类（Comparable接口只能用于排序的类的实现上）
        Comparator<User> userComparator = new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                //写法一
                int result = o1.getName().compareTo(o2.getName());
                if(result > 0){
                    return 1;
                }else if(result < 0){
                    return -1;
                }
                return 0;

                //写法二（效果一样）
//                return o1.getName().compareTo(o2.getName());
            }
        };

        Collections.sort(userList,userComparator);
        for(User user : userList){
            System.out.println(user.toString());
        }


        System.out.println("按名字排序(降序)");
        Comparator<User> userComparator2 = new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                int result = o1.getName().compareTo(o2.getName());
                if(result > 0){
                    return -1;
                }else if(result < 0){
                    return 1;
                }
                return 0;
            }
        };
        Collections.sort(userList,userComparator2);
        for(User user : userList){
            System.out.println(user.toString());
        }

        System.out.println("按年龄排序(升序)");
        Collections.sort(userList,new AgeComparator());
        for(User user : userList){
            System.out.println(user.toString());
        }

        System.out.println("按年龄排序(降序)");
        Collections.sort(userList,new AgeComparator2());
        for(User user : userList){
            System.out.println(user.toString());
        }

        System.out.println("\n***************用Comparable排序(先按名字降序排列，再按年龄升序排列)***************");
        Collections.sort(userList);
        for(User user : userList){
            System.out.println(user.toString());
        }

测试结果：

***************纯数字排序Collections.sort(integerList)***************
默认排序
[1, 2, 3]
倒序排序
[3, 2, 1]

***************纯字母排序Collections.sort(stringList)***************
默认排序
[a, b, c]
倒序排序
[c, b, a]

***************自定义排序***************
按名字排序(升序)
name:aa age:18
name:aa age:17
name:ab age:19
按名字排序(降序)
name:ab age:19
name:aa age:18
name:aa age:17
按年龄排序(升序)
name:aa age:17
name:aa age:18
name:ab age:19
按年龄排序(降序)
name:ab age:19
name:aa age:18
name:aa age:17

***************用Comparable排序(先按名字降序排列，再按年龄升序排列)***************
name:ab age:19
name:aa age:17
name:aa age:18

User类

public class User implements Comparable<User>{
    private String name;
    private int age;

    public User(String name, int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String toString(){
        return "name:" + this.name + " age:" + this.age;
    }

    //先按名字降序排列，再按年龄升序排列
    @Override
    public int compareTo(User o) {
        int nameResult = this.getName().compareTo(o.getName());
        if(nameResult > 0){
            return -1;
        }else if(nameResult < 0){
            return 1;
        }
        int ageResult = this.getAge() - o.getAge();
        if(ageResult > 0){
            return 1;
        }else if(ageResult < 0){
            return -1;
        }
        return 0;
    }
}

Comparator比较器

public class AgeComparator implements Comparator<User> {
    @Override
    public int compare(User o1, User o2) {
        return o1.getAge() - o2.getAge();
    }
}

public class AgeComparator2 implements Comparator<User> {
    @Override
    public int compare(User o1, User o2) {
        int result = o1.getAge() - o2.getAge();
        if(result > 0){
            return -1;
        }else if(result < 0){
            return 1;
        }
        return 0;
    }
}