Java 比较器Comparable与Comparator的List集合排序使用

一、Collections类

    Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。

 用于集合排序的sort方法，此方法主要是通过Comparable或Comparator来实现排序。

(1) 根据其元素的natural orderinig对指定的列表进行排序

(2) 根据指定的比较器引起的顺序对指定的列表进行排序 

二、Comparable比较器

        在使用Collections的sort(List<T> list) 方法排序时，要求集合元素（对象）T必须是Comparable接口的实现类，同时重写Comparable的抽象方法 - int compareTo(T t)

 (1) 自定义对象排序:按照价格进行升序排序

public class Goods implements  Comparable<Goods> {
    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    private String name;
    private double  price;

    //构造器、getter、setter、toString()方法略
    public Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public Goods() {
    }

    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    //按照价格，比较商品的大小
    @Override
    public int compareTo(Goods o) {
        return   (int)(this.price - o.price);
    }
}

class TestGoods{
    public static void main(String[] args) {
        List<Goods> list =new ArrayList<>();
        list.add(new Goods("《红楼梦》", 100));
        list.add(new Goods("《西游记》", 88));
        list.add(new Goods("《三国演义》", 130));
        list.add(new Goods("《水浒传》", 110));
        System.out.println("排序前");
        System.out.println(list.toString());

        System.out.println("排序后");
        Collections.sort(list);
        System.out.println(list.toString());
    }
}

测试：

 Comparable优缺点

       通过案例知道，Comparable的确实现了我们想要的排序结果。但是使用Collections的sort(List<T> list) 方法排序集合时，集合元素必须实现Comparable接口并且定义比较规则。这个时候就开始出现一些问题。比如我们同一个工程使用了Goods对象，单个场景使用price进行排序，但是另一种情况下使用name排序，这个时候就出现了冲突。并且集合元素需要去实现Comparable接口，这对于我们的代码会有一些"侵入性"，也不利于我们后续的代码扩展。

所以一般不建议使用，推荐使用Collections的sort(List<T> list, Comparator<? super T> c)的重载方法。

三、Comparator用法

重载sort方法：传入一个外部的比较器。
推荐使用这种方式排序集合元素，若集合元素是自定义的，创建比较器时也推荐使用匿名内部类的形式。

  (1) 自定义对象排序 + 使用List自带的排序

public class Student {
    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    String name;
    Integer age;

    Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

class TestComparator{
    public static void main(String[] args) {
//        System.out.println(test1());
        System.out.println(test2());
    }

    /**
     * Collections.sort()测试
     * @return
     */
    private static List<Student> test1() {
        //自定义对象排序
        List<Student> students = Arrays.asList(new Student("周军",20),new Student("刘飞",18),new Student("王丽",19));

        // 使用匿名内部类进行排序
        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 自定义排序规则
                return o1.age-o2.age;
            }
        });
        return students;
    }

    /**
     * List.sort()测试
     * @return
     */
    private static List<Student> test2() {
        //自定义对象排序
        List<Student> students = Arrays.asList(new Student("周军",20),new Student("刘飞",18),new Student("王丽",19));

        // 使用匿名内部类进行排序
      students.sort(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 自定义排序规则
                return o1.age-o2.age;
            }
        });
        return students;
    }
}

测试：

四、使用lambda简化Comparator接口

   Comparator接口是一个函数式接口，所以我们可以使用更优秀的写法，简化代码。

函数式接口就是只定义一个抽象方法的接口。
JDK1.8开始支持默认方法，即便这个接口拥有很多默认方法，只要接口只有一个抽象方法，那么这个接口就是函数式接口。

 测试：