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

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

一、Collections类

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

用于集合排序的sort方法,此方法主要是通过ComparableComparator来实现排序。

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

测试:

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

测试:

7609875cfc7b448a85218969a616efc5.png

四、使用lambda简化Comparator接口

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

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

4e57b0539f9147e49788203d216a03ee.png

测试:

705ece34da004a15ab7c710902925dcf.png

发表评论

表情:
评论列表 (有 0 条评论,124人围观)

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

相关阅读