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

布满荆棘的人生 2023-10-08 18:09 132阅读 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) 自定义对象排序:按照价格进行升序排序

  1. public class Goods implements  Comparable<Goods> {
  2.     public String getName() {
  3.         return name;
  4.     }
  6.     public void setName(String name) {
  7.         this.name = name;
  8.     }
  10.     public double getPrice() {
  11.         return price;
  12.     }
  14.     public void setPrice(double price) {
  15.         this.price = price;
  16.     }
  18.     private String name;
  19.     private double  price;
  21.     //构造器、getter、setter、toString()方法略
  22.     public Goods(String name, double price) {
  23.         this.name = name;
  24.         this.price = price;
  25.     }
  27.     public Goods() {
  28.     }
  30.     @Override
  31.     public String toString() {
  32.         return "Goods{" +
  33.                 "name='" + name + '\'' +
  34.                 ", price=" + price +
  35.                 '}';
  36.     }
  38.     //按照价格，比较商品的大小
  39.     @Override
  40.     public int compareTo(Goods o) {
  41.         return   (int)(this.price - o.price);
  42.     }
  43. }
  45. class TestGoods{
  46.     public static void main(String[] args) {
  47.         List<Goods> list =new ArrayList<>();
  48.         list.add(new Goods("《红楼梦》", 100));
  49.         list.add(new Goods("《西游记》", 88));
  50.         list.add(new Goods("《三国演义》", 130));
  51.         list.add(new Goods("《水浒传》", 110));
  52.         System.out.println("排序前");
  53.         System.out.println(list.toString());
  55.         System.out.println("排序后");
  56.         Collections.sort(list);
  57.         System.out.println(list.toString());
  58.     }
  59. }

测试：

8f8d8275892849ad9fee9b385f84c849.png

Comparable优缺点

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

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

三、Comparator用法

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

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

  1. public class Student {
  2.     public String getName() {
  3.         return name;
  4.     }
  6.     public void setName(String name) {
  7.         this.name = name;
  8.     }
  10.     public Integer getAge() {
  11.         return age;
  12.     }
  14.     public void setAge(Integer age) {
  15.         this.age = age;
  16.     }
  18.     String name;
  19.     Integer age;
  21.     Student(String name, Integer age) {
  22.         this.name = name;
  23.         this.age = age;
  24.     }
  26.     @Override
  27.     public String toString() {
  28.         return "{" +
  29.                 "name='" + name + '\'' +
  30.                 ", age=" + age +
  31.                 '}';
  32.     }
  33. }
  35. class TestComparator{
  36.     public static void main(String[] args) {
  37. //        System.out.println(test1());
  38.         System.out.println(test2());
  39.     }
  41.     /**
  42.      * Collections.sort()测试
  43.      * @return
  44.      */
  45.     private static List<Student> test1() {
  46.         //自定义对象排序
  47.         List<Student> students = Arrays.asList(new Student("周军",20),new Student("刘飞",18),new Student("王丽",19));
  49.         // 使用匿名内部类进行排序
  50.         Collections.sort(students, new Comparator<Student>() {
  51.             @Override
  52.             public int compare(Student o1, Student o2) {
  53.                 // 自定义排序规则
  54.                 return o1.age-o2.age;
  55.             }
  56.         });
  57.         return students;
  58.     }
  60.     /**
  61.      * List.sort()测试
  62.      * @return
  63.      */
  64.     private static List<Student> test2() {
  65.         //自定义对象排序
  66.         List<Student> students = Arrays.asList(new Student("周军",20),new Student("刘飞",18),new Student("王丽",19));
  68.         // 使用匿名内部类进行排序
  69.       students.sort(new Comparator<Student>() {
  70.             @Override
  71.             public int compare(Student o1, Student o2) {
  72.                 // 自定义排序规则
  73.                 return o1.age-o2.age;
  74.             }
  75.         });
  76.         return students;
  77.     }
  78. }

测试：

7609875cfc7b448a85218969a616efc5.png

四、使用lambda简化Comparator接口

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

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

4e57b0539f9147e49788203d216a03ee.png

测试：

705ece34da004a15ab7c710902925dcf.png

发表评论

表情：
评论列表 （有 0 条评论，132人围观）

还没有评论，来说两句吧...

相关阅读