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

布满荆棘的人生 2023-10-08 18:09 54阅读 0赞

### 一、Collections类 ###

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

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

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

![29a41c1c9a2f40bcb62e6e468effc3a3.png][]

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

![fc65405aa86744fb99e11fa031e22a47.png][]

### 二、Comparable比较器 ###

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

![1739972e0e4442af9af4c3624089a3f2.png][]

(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());
        }
    }

测试：

![8f8d8275892849ad9fee9b385f84c849.png][]

> 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;
        }
    }

测试：

![7609875cfc7b448a85218969a616efc5.png][]

### 四、使用lambda简化Comparator接口 ###

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

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

![4e57b0539f9147e49788203d216a03ee.png][]

测试：

![705ece34da004a15ab7c710902925dcf.png][]

[29a41c1c9a2f40bcb62e6e468effc3a3.png]: https://img-blog.csdnimg.cn/29a41c1c9a2f40bcb62e6e468effc3a3.png
[fc65405aa86744fb99e11fa031e22a47.png]: https://img-blog.csdnimg.cn/fc65405aa86744fb99e11fa031e22a47.png
[compareTo]: https://so.csdn.net/so/search?q=compareTo
[1739972e0e4442af9af4c3624089a3f2.png]: https://img-blog.csdnimg.cn/1739972e0e4442af9af4c3624089a3f2.png
[8f8d8275892849ad9fee9b385f84c849.png]: https://img-blog.csdnimg.cn/8f8d8275892849ad9fee9b385f84c849.png
[7609875cfc7b448a85218969a616efc5.png]: https://img-blog.csdnimg.cn/7609875cfc7b448a85218969a616efc5.png
[4e57b0539f9147e49788203d216a03ee.png]: https://img-blog.csdnimg.cn/4e57b0539f9147e49788203d216a03ee.png
[705ece34da004a15ab7c710902925dcf.png]: https://img-blog.csdnimg.cn/705ece34da004a15ab7c710902925dcf.png