• Comparator 和 Comparable比较

    Comparable是排序接口: 若一个类实现了Comparable接口，就意味着“该类支持排序”。

    Comparator是比较器: 我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。

    我们需要创建一个包含了用户列表的 List 集合，并按用户的年龄从大到小进行排序，具体实现代码如下： 第一种：实现Comparable<>接口

     写一个Person类：

    1. class Person implements Comparable<Person>{
    2.  
    3.         Integer id;
    4.         String name;
    5.         Integer age;
    6.  
    7.         public Integer getId() {
    8.             return id;
    9.         }
    10.  
    11.         public void setId(Integer id) {
    12.             this.id = id;
    13.         }
    14.  
    15.         public String getName() {
    16.             return name;
    17.         }
    18.  
    19.         public void setName(String name) {
    20.             this.name = name;
    21.         }
    22.  
    23.         public Integer getAge() {
    24.             return age;
    25.         }
    26.  
    27.         public void setAge(Integer age) {
    28.             this.age = age;
    29.         }
    30.         @Override
    31.         public String toString() {
    32.             return "Person{" +
    33.                     "id=" + id +
    34.                     ", name='" + name + '\'' +
    35.                     ", age=" + age +
    36.                     '}';
    37.         }
    38.         @Override
    39.         public int compareTo(Person o) {
    40.             //按照年龄从大到小排序
    41.             return o.getAge()-this.getAge();
    42.         }
    43.     }

    实现结果测试：

    1. public static void main(String[] args){
    2.         //假设放进去三个对象，直接调用
    3.         List<Person> pr=new ArrayList<Person>(){{
    4.             add(new Person(1,"huitao1",32));
    5.             add(new Person(2,"huitao2",40));
    6.             add(new Person(3,"huitao3",28));
    8.         }};
    9.         //很重要
    10.         Collections.sort(pr);
    11.         pr.forEach(p->{
    12.             System.out.print(p);
    13.         });
    14.     }

    结果按照40、32、28进行了排序 

     第二种： Comparator 排序

    Comparable 是类内部的比较方法，而 Comparator 是排序类外部的比较器。使用 Comparator 比较器，无需修改原 Person 类，只需要扩充一个 Person 类的比较器就行了，Comparator 的实现方法有以下两种：

    • 新建 Comparator 比较器；
    • 使用 Comparator 匿名类比较器。

     

    1. static class Person {
    2.  
    3.         Integer id;
    4.         String name;
    5.         Integer age;
    6.  
    7.         public Person(Integer id, String name, Integer age) {
    8.             this.id = id;
    9.             this.name = name;
    10.             this.age = age;
    11.         }
    12.  
    13.         public Integer getId() {
    14.             return id;
    15.         }
    16.  
    17.         public void setId(Integer id) {
    18.             this.id = id;
    19.         }
    20.  
    21.         public String getName() {
    22.             return name;
    23.         }
    24.  
    25.         public void setName(String name) {
    26.             this.name = name;
    27.         }
    28.  
    29.         public Integer getAge() {
    30.             return age;
    31.         }
    32.  
    33.         public void setAge(Integer age) {
    34.             this.age = age;
    35.         }
    36.  
    37.         @Override
    38.         public String toString() {
    39.             return "Person{" +
    40.                     "id=" + id +
    41.                     ", name='" + name + '\'' +
    42.                     ", age=" + age +
    43.                     '}';
    44.         }
    45.     }

    编写一个比较器类： 

    1. static class ToPerson implements Comparator<Person>{
    2.  
    3.         @Override
    4.         public int compare(Person o1, Person o2) {
    5.             return o1.getAge() - o2.getAge();
    6.         }
    7.     }
    1. public static void main(String[] args){
    2.  
    3.  
    4.  
    5.         List<Person> pr=new ArrayList<Person>(){{
    6.             add(new Person(1,"huitao1",32));
    7.             add(new Person(2,"huitao2",40));
    8.             add(new Person(3,"huitao3",28));
    10.         }};
    11.         //很重要
    12.         Collections.sort(pr,new ToPerson());
    13.         pr.forEach(p->{
    14.             System.out.print(p);
    15.         });
    16.     }

    测试结果：

    分别为28、32、40，如果要从大到小，可以编写为

    static class ToPerson implements Comparator{

    @Override
    public int compare(Person o1, Person o2) {
        return o2.getAge() - o1.getAge();
    }
}

    以匿名类的方式访问：

    1. static class Person {
    2.  
    3.         Integer id;
    4.         String name;
    5.         Integer age;
    6.  
    7.         public Person(Integer id, String name, Integer age) {
    8.             this.id = id;
    9.             this.name = name;
    10.             this.age = age;
    11.         }
    12.  
    13.         public Integer getId() {
    14.             return id;
    15.         }
    16.  
    17.         public void setId(Integer id) {
    18.             this.id = id;
    19.         }
    20.  
    21.         public String getName() {
    22.             return name;
    23.         }
    24.  
    25.         public void setName(String name) {
    26.             this.name = name;
    27.         }
    28.  
    29.         public Integer getAge() {
    30.             return age;
    31.         }
    32.  
    33.         public void setAge(Integer age) {
    34.             this.age = age;
    35.         }
    36.  
    37.         @Override
    38.         public String toString() {
    39.             return "Person{" +
    40.                     "id=" + id +
    41.                     ", name='" + name + '\'' +
    42.                     ", age=" + age +
    43.                     '}';
    44.         }
    45.     }
    1.  public static void main(String[] args){
    2.  
    3.  
    4.  
    5.         List<Person> pr=new ArrayList<Person>(){{
    6.             add(new Person(1,"huitao1",32));
    7.             add(new Person(2,"huitao2",40));
    8.             add(new Person(3,"huitao3",28));
    10.         }};
    11.         //很重要
    12.         Collections.sort(pr, new Comparator<Person>() {
    13.             @Override
    14.             public int compare(Person o1, Person o2) {
    15.                 return o2.getAge() - o1.getAge();
    16.             }
    17.         });
    18.         pr.forEach(p->{
    19.             System.out.print(p);
    20.         });
    21.     }

    第三种：使用 Stream 流排序 

    1. public static void main(String[] args){
    2.  
    3.  
    4.  
    5.         List<Person> pr=new ArrayList<Person>(){{
    6.             add(new Person(1,"huitao1",32));
    7.             add(new Person(2,"huitao2",40));
    8.             add(new Person(3,"huitao3",28));
    9.  
    10.         }};
    11.         pr= pr.stream().sorted(Comparator.comparing(Person::getAge).reversed()).collect(Collectors.toList());
    12.         pr.forEach(p->{
    13.             System.out.print(p);
    14.         });
    15.     }
    16.     static class Person {
    17.  
    18.         Integer id;
    19.         String name;
    20.         Integer age;
    21.  
    22.         public Person(Integer id, String name, Integer age) {
    23.             this.id = id;
    24.             this.name = name;
    25.             this.age = age;
    26.         }
    27.  
    28.         public Integer getId() {
    29.             return id;
    30.         }
    31.  
    32.         public void setId(Integer id) {
    33.             this.id = id;
    34.         }
    35.  
    36.         public String getName() {
    37.             return name;
    38.         }
    39.  
    40.         public void setName(String name) {
    41.             this.name = name;
    42.         }
    43.  
    44.         public Integer getAge() {
    45.             return age;
    46.         }
    47.  
    48.         public void setAge(Integer age) {
    49.             this.age = age;
    50.         }
    51.  
    52.         @Override
    53.         public String toString() {
    54.             return "Person{" +
    55.                     "id=" + id +
    56.                     ", name='" + name + '\'' +
    57.                     ", age=" + age +
    58.                     '}';
    59.         }
    60.     }

     

     stream()如果排序属性出现null,报告空指针个错误，解决办法

    1. public static void main(String[] args){
    2.  
    3.  
    4.  
    5.         List<Person> pr=new ArrayList<Person>(){{
    6.             add(new Person(1,"huitao1",32));
    7.             add(new Person(2,"huitao2",40));
    8.             add(new Person(3,"huitao3",28));
    9.             add(new Person(4,"huitao3",null));
    10.  
    11.         }};
    12.         pr= pr.stream().sorted(Comparator.comparing(Person::getAge,Comparator.nullsFirst(Integer::compareTo)).reversed()).collect(Collectors.toList());
    13.         pr.forEach(p->{
    14.             System.out.print(p);
    15.         });
    16.     }
    17.     static class Person {
    18.  
    19.         Integer id;
    20.         String name;
    21.         Integer age;
    22.  
    23.         public Person(Integer id, String name, Integer age) {
    24.             this.id = id;
    25.             this.name = name;
    26.             this.age = age;
    27.         }
    28.  
    29.         public Integer getId() {
    30.             return id;
    31.         }
    32.  
    33.         public void setId(Integer id) {
    34.             this.id = id;
    35.         }
    36.  
    37.         public String getName() {
    38.             return name;
    39.         }
    40.  
    41.         public void setName(String name) {
    42.             this.name = name;
    43.         }
    44.  
    45.         public Integer getAge() {
    46.             return age;
    47.         }
    48.  
    49.         public void setAge(Integer age) {
    50.             this.age = age;
    51.         }
    52.  
    53.         @Override
    54.         public String toString() {
    55.             return "Person{" +
    56.                     "id=" + id +
    57.                     ", name='" + name + '\'' +
    58.                     ", age=" + age +
    59.                     '}';
    60.         }
    61.     }

     

    Comparator.nullsFirst 表示将排序字段中的 null 值放到集合最前面，如果想要将 null 值放到集合最后面可以使用 Comparator.nullsLast。 

  • 相关阅读:
    浏览量5.54亿，“平替大军”击退“钱包刺客”？丨小红书消费趋势分析
    数据结构与算法:树 顺序存储二叉树(二)
    flutter 版本更新
    【C语言】程序环境深度剖析
    【python-AI篇】人工智能技能树思维导图
    《吐血整理》保姆级系列教程-玩转Fiddler抓包教程(2)-初识Fiddler让你理性认识一下
    2022年，有哪些适合普通人的风口项目？
    [附源码]Python计算机毕业设计高校辅导员工作管理系统
    Vue3学习系列之《列表渲染》
    测试人员学Java入门指南
  • 原文地址：https://blog.csdn.net/chehec2010/article/details/133362757