devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Comparator.comparing比较排序_comparator comparing

作者：小小林熬夜学编程 | 2024-04-03 10:23:53

赞

踩

comparator comparing

Java8 - 使用 Comparator.comparing 进行比较排序

使用外部比较器Comparator进行排序

当我们需要对集合的元素进行排序的时候，可以使用java.util.Comparator 创建一个比较器来进行排序。Comparator接口同样也是一个函数式接口，我们可以把使用lambda表达式。如下示例，

  1. package com.common;
  2.  
  3. import java.util.*;
  4. import java.util.stream.Collectors;
  5.  
  6. public class ComparatorTest {
  7.     public static void main(String[] args) {
  8.  
  9.         Employee e1 = new Employee("John", 25, 3000, 9922001);
  10.         Employee e2 = new Employee("Ace", 22, 2000, 5924001);
  11.         Employee e3 = new Employee("Keith", 35, 4000, 3924401);
  12.  
  13.         List<Employee> employees = new ArrayList<>();
  14.         employees.add(e1);
  15.         employees.add(e2);
  16.         employees.add(e3);
  17.  
  18.         /**
  19.          *     @SuppressWarnings({"unchecked", "rawtypes"})
  20.          *     default void sort(Comparator<? super E> c) {
  21.          *         Object[] a = this.toArray();
  22.          *         Arrays.sort(a, (Comparator) c);
  23.          *         ListIterator<E> i = this.listIterator();
  24.          *         for (Object e : a) {
  25.          *             i.next();
  26.          *             i.set((E) e);
  27.          *         }
  28.          *     }
  29.          *
  30.          *     sort 对象接收一个 Comparator 函数式接口，可以传入一个lambda表达式
  31.          */
  32.         employees.sort((o1, o2) -> o1.getName().compareTo(o2.getName()));
  33.  
  34.         Collections.sort(employees, (o1, o2) -> o1.getName().compareTo(o2.getName()));
  35.  
  36.         employees.forEach(System.out::println);
  37.     }
  38. }
  39.  
  40.  
  41. /**
  42.  * [Employee(name=John, age=25, salary=3000.0, mobile=9922001),
  43.  * Employee(name=Ace, age=22, salary=2000.0, mobile=5924001),
  44.  * Employee(name=Keith, age=35, salary=4000.0, mobile=3924401)]
  45.  */
  46. class Employee {
  47.     String name;
  48.     int age;
  49.     double salary;
  50.     long mobile;
  51.  
  52.     // constructors, getters & setters
  53.  
  54.  
  55.     public Employee(String name, int age, double salary, long mobile) {
  56.         this.name = name;
  57.         this.age = age;
  58.         this.salary = salary;
  59.         this.mobile = mobile;
  60.     }
  61.  
  62.     public String getName() {
  63.         return name;
  64.     }
  65.  
  66.     public void setName(String name) {
  67.         this.name = name;
  68.     }
  69.  
  70.     public int getAge() {
  71.         return age;
  72.     }
  73.  
  74.     public void setAge(int age) {
  75.         this.age = age;
  76.     }
  77.  
  78.     public double getSalary() {
  79.         return salary;
  80.     }
  81.  
  82.     public void setSalary(double salary) {
  83.         this.salary = salary;
  84.     }
  85.  
  86.     public long getMobile() {
  87.         return mobile;
  88.     }
  89.  
  90.     public void setMobile(long mobile) {
  91.         this.mobile = mobile;
  92.     }
  93.  
  94.     @Override
  95.     public String toString() {
  96.         final StringBuilder sb = new StringBuilder("Employee{");
  97.         sb.append("name='").append(name).append('\'');
  98.         sb.append(", age=").append(age);
  99.         sb.append(", salary=").append(salary);
  100.         sb.append(", mobile=").append(mobile);
  101.         sb.append('}');
  102.         return sb.toString();
  103.     }
  104. }

 

使用 Comparator.comparing 进行排序

comparing 方法一

查看 Comparator 类内部实现，还有一个 comparing 方法，实现如下，

  1.     public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
  2.             Function<? super T, ? extends U> keyExtractor)
  3.     {
  4.         Objects.requireNonNull(keyExtractor);
  5.         return (Comparator<T> & Serializable)
  6.             (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
  7.     }

其返回值是 (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2)); 一个lambda表达式，也就是一个Compator 。所以上面那个例子也可以改造成 如下，

  1. package com.common;
  2.  
  3. import java.util.*;
  4.  
  5. public class ComparatorTest {
  6.     public static void main(String[] args) {
  7.  
  8.         Employee e1 = new Employee("John", 25, 3000, 9922001);
  9.         Employee e2 = new Employee("Ace", 22, 2000, 5924001);
  10.         Employee e3 = new Employee("Keith", 35, 4000, 3924401);
  11.  
  12.         List<Employee> employees = new ArrayList<>();
  13.         employees.add(e1);
  14.         employees.add(e2);
  15.         employees.add(e3);
  16.  
  17.         /**
  18.          *     @SuppressWarnings({"unchecked", "rawtypes"})
  19.          *     default void sort(Comparator<? super E> c) {
  20.          *         Object[] a = this.toArray();
  21.          *         Arrays.sort(a, (Comparator) c);
  22.          *         ListIterator<E> i = this.listIterator();
  23.          *         for (Object e : a) {
  24.          *             i.next();
  25.          *             i.set((E) e);
  26.          *         }
  27.          *     }
  28.          *
  29.          *     sort 对象接收一个 Comparator 函数式接口，可以传入一个lambda表达式
  30.          */
  31.         employees.sort((o1, o2) -> o1.getName().compareTo(o2.getName()));
  32.  
  33.         Collections.sort(employees, (o1, o2) -> o1.getName().compareTo(o2.getName()));
  34.  
  35.         employees.forEach(System.out::println);
  36.  
  37.  
  38.         /**
  39.          * Comparator.comparing 方法的使用
  40.          *
  41.          * comparing 方法接收一个 Function 函数式接口 ，通过一个 lambda 表达式传入
  42.          *
  43.          */
  44.         employees.sort(Comparator.comparing(e -> e.getName()));
  45.  
  46.         /**
  47.          * 该方法引用 Employee::getName 可以代替 lambda表达式
  48.          */
  49.         employees.sort(Comparator.comparing(Employee::getName));
  50.  
  51.     }
  52. }
  53.  
  54.  
  55. /**
  56.  * [Employee(name=John, age=25, salary=3000.0, mobile=9922001),
  57.  * Employee(name=Ace, age=22, salary=2000.0, mobile=5924001),
  58.  * Employee(name=Keith, age=35, salary=4000.0, mobile=3924401)]
  59.  */
  60. class Employee {
  61.     String name;
  62.     int age;
  63.     double salary;
  64.     long mobile;
  65.  
  66.     // constructors, getters & setters
  67.  
  68.  
  69.     public Employee(String name, int age, double salary, long mobile) {
  70.         this.name = name;
  71.         this.age = age;
  72.         this.salary = salary;
  73.         this.mobile = mobile;
  74.     }
  75.  
  76.     public String getName() {
  77.         return name;
  78.     }
  79.  
  80.     public void setName(String name) {
  81.         this.name = name;
  82.     }
  83.  
  84.     public int getAge() {
  85.         return age;
  86.     }
  87.  
  88.     public void setAge(int age) {
  89.         this.age = age;
  90.     }
  91.  
  92.     public double getSalary() {
  93.         return salary;
  94.     }
  95.  
  96.     public void setSalary(double salary) {
  97.         this.salary = salary;
  98.     }
  99.  
  100.     public long getMobile() {
  101.         return mobile;
  102.     }
  103.  
  104.     public void setMobile(long mobile) {
  105.         this.mobile = mobile;
  106.     }
  107.  
  108.     @Override
  109.     public String toString() {
  110.         final StringBuilder sb = new StringBuilder("Employee{");
  111.         sb.append("name='").append(name).append('\'');
  112.         sb.append(", age=").append(age);
  113.         sb.append(", salary=").append(salary);
  114.         sb.append(", mobile=").append(mobile);
  115.         sb.append('}');
  116.         return sb.toString();
  117.     }
  118. }

 

comparing 方法二

  1.     public static <T, U> Comparator<T> comparing(
  2.             Function<? super T, ? extends U> keyExtractor,
  3.             Comparator<? super U> keyComparator)
  4.     {
  5.         Objects.requireNonNull(keyExtractor);
  6.         Objects.requireNonNull(keyComparator);
  7.         return (Comparator<T> & Serializable)
  8.             (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
  9.                                               keyExtractor.apply(c2));
  10.     }

和comparing 方法一不同的是 该方法多了一个参数 keyComparator ，keyComparator 是创建一个自定义的比较器。

  1. Collections.sort(employees, Comparator.comparing(
  2.                 Employee::getName, (s1, s2) -> {
  3.                     return s2.compareTo(s1);
  4.                 }));

 

使用 Comparator.reversed 进行排序

返回相反的排序规则，

  1. /**
  2.  *  相反的排序规则
  3.  */
  4. Collections.sort(employees, Comparator.comparing(Employee::getName).reversed());
  5.  
  6. employees.forEach(System.out::println);

输出，

  1. Employee{name='Keith', age=35, salary=4000.0, mobile=3924401}
  2. Employee{name='John', age=25, salary=3000.0, mobile=9922001}
  3. Employee{name='Ace', age=22, salary=2000.0, mobile=5924001}

 

使用 Comparator.nullsFirst进行排序

当集合中存在null元素时，可以使用针对null友好的比较器，null元素排在集合的最前面

  1. employees.add(null);  //插入一个null元素
  2. Collections.sort(employees, Comparator.nullsFirst(Comparator.comparing(Employee::getName)));
  3. employees.forEach(System.out::println);
  4.  
  5.  
  6. Collections.sort(employees, Comparator.nullsLast(Comparator.comparing(Employee::getName)));
  7. employees.forEach(System.out::println);

 

使用 Comparator.thenComparing 排序

首先使用 name 排序，紧接着在使用ege 排序，来看下使用效果

  1. Collections.sort(employees, Comparator.comparing(Employee::getAge).thenComparing(Employee::getName));
  2. employees.forEach(System.out::println);

 转载：https://my.oschina.net/xinxingegeya/blog/2046405

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/355136
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号