本文共 6218 字，大约阅读时间需要 20 分钟。

一、概述

  Comparable和Comparator都是两个接口，接口都可以用来实现集合中元素的比较、排序，Comparator位于包java.util下，而Comparable位于包java.lang下，Comparable接口将比较代码嵌入自身类中，而Comparator既可以嵌入到自身类中，也可以在一个独立的类中实现比较。

Integer、String等这些基本类型的JAVA封装类都已经实现了Comparable接口，这些类对象本身就支持自比较，直接调用Collections.sort()就可以对集合中元素的排序，无需自己去实现Comparable接口。 而有些自定义类的List序列，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较，也就是指定使用Comparator（临时规则排序，也称作专门规则排序），如果不指定Comparator，那么就用自然规则排序，这里的自然顺序就是实现Comparable接口设定的排序方式。

二、Comparable

  Comparable可以认为是一个内比较器，实现了Comparable接口的类有一个特点，就是这些类是可以和自己比较的，至于具体和另一个实现了Comparable接口的类如何比较，则依赖compareTo方法的实现，compareTo方法也被称为自然比较方法。如果开发者add进入一个Collection的对象想要Collections的sort方法帮你自动进行排序的话，那么这个对象必须实现Comparable接口。compareTo方法的返回值是int，有三种情况：

1、比较者大于被比较者（也就是compareTo方法里面的对象），那么返回正整数 2、比较者等于被比较者，那么返回0 3、比较者小于被比较者，那么返回负整数

三、Comparator

  Comparator可以认为是是一个外比较器，个人认为有两种情况可以使用实现Comparator接口的方式：

1、一个对象不支持自己和自己比较（没有实现Comparable接口），但是又想对两个对象进行比较 2、一个对象实现了Comparable接口，但是开发者认为compareTo方法中的比较方式并不是自己想要的那种比较方式

  Comparator接口里面有一个compare方法，方法有两个参数T o1和T o2，是泛型的表示方式，分别表示待比较的两个对象，方法返回值和Comparable接口一样是int，有三种情况：

1、o1大于o2，返回正整数 2、o1等于o2，返回0 3、o1小于o3，返回负整数

四、Comparator和Comparable的区别

  一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序。

Comparator可以看成一种算法的实现，将算法和数据分离，Comparator也可以在下面两种环境下使用： 1、类的设计师没有考虑到比较问题而没有实现Comparable，可以通过Comparator来实现排序而不必改变对象本身 2、可以使用多种排序标准，比如升序、降序等

总结一下，两种比较器Comparable和Comparator，后者相比前者有如下优点：

1、如果实现类没有实现Comparable接口，又想对两个类进行比较（或者实现类实现了Comparable接口，但是对compareTo方法内的比较算法不满意），那么可以实现Comparator接口，自定义一个比较器，写比较算法 2、实现Comparable接口的方式比实现Comparator接口的耦合性要强一些，如果要修改比较算法，则需要修改Comparable接口的实现类，而实现Comparator的类是在外部进行比较的，不需要对实现类有任何修改。从这个角度说，实现Comparable接口的方式其实有些不太好，尤其在我们将实现类的.class文件打成一个.jar文件提供给开发者使用的时候。实际上实现Comparator 接口的方式后面会写到就是一种典型的策略模式。

五、实现方式

下面我们看一下具体实现方式：

1、Comparable 首先来看一下Comparable接口，我们想要对一个类自身进行排序，那么我们可以让这个类实现Comparable接口，重写其中的compareTo方法完成：

package com.dl.pojo;import java.util.ArrayList;import java.util.Collections;import java.util.List;public class User implements Comparable
   
     {
      //该类实现Comparable接口，参数为User    private String name;    private int age;    private boolean sex;    public User() {
       }    public User(String name, int age, boolean sex) {
           this.name = name;        this.age = age;        this.sex = sex;    }    @Override    public String toString() {
           return "User{" +                "name='" + name + '\'' +                ", age=" + age +                ", sex=" + sex +                '}';    }    public String getName() {
           return name;    }    public void setName(String name) {
           this.name = name;    }    public int getAge() {
           return age;    }    public void setAge(int age) {
           this.age = age;    }    public boolean isSex() {
           return sex;    }    public void setSex(boolean sex) {
           this.sex = sex;    }    /**    * 重写compareTo方法，实现年龄升序,年龄相同则姓名升序    **/    @Override    public int compareTo(User user) {
            if(this.age==user.age) return this.name.compareTo(user.name);        return this.age-user.age; //将this想像成一排不变的对象(已经按照要求排好序的)，而User就是当前要插入的对象，只有user属性小于this属性才插入从而升序，个人理解，希望有所帮助    }}class Test{
       public static void main(String[] args) {
           User user1=new User("dingxx",25,true);        User user2=new User("huxx",24,false);        User user3=new User("xxx",24,false);        List
    
      list=new ArrayList
     
      ();        list.add(user1);        list.add(user2);        list.add(user3);        Collections.sort(list);        System.out.println("Comparable:"+list);    }}
     
    
   

结果：

2、Comparator 在第二种实现方式Comparator接口中，总结了类自身实现Comparator接口重写compare方法的比较器、类外实现比较器和使用Lambda表达式简化比较器实现。

package com.dl.pojo;import java.util.ArrayList;import java.util.Collections;import java.util.Comparator;import java.util.List;public class User implements Comparator
   
     {
       private String name;    private int age;    private boolean sex;    public User() {
       }    public User(String name, int age, boolean sex) {
           this.name = name;        this.age = age;        this.sex = sex;    }    @Override    public String toString() {
           return "User{" +                "name='" + name + '\'' +                ", age=" + age +                ", sex=" + sex +                '}';    }    public String getName() {
           return name;    }    public void setName(String name) {
           this.name = name;    }    public int getAge() {
           return age;    }    public void setAge(int age) {
           this.age = age;    }    public boolean isSex() {
           return sex;    }    public void setSex(boolean sex) {
           this.sex = sex;    }    @Override    public int compare(User o1, User o2) {
           return o1.age-o2.age;    }}class Test{
       public static void main(String[] args) {
           User user1=new User("dingli",25,true);        User user2=new User("huxiaojuan",24,false);        User user3=new User("xxx",24,false);        List
    
      list=new ArrayList
     
      ();        list.add(user1);        list.add(user2);        list.add(user3);        Collections.sort(list, new User()); //类实现了的Comparator能满足需求        System.out.println("类自身实现Comparator:"+list);        //现在我想要按照名字升序，显然类中实现的不能满足要求，于是可以在类外自己实现想要的比较器        Collections.sort(list, new Comparator
      
       () {
               @Override            public int compare(User o1, User o2) {
                   return o1.getName().compareTo(o2.getName()); //按照名字升序            }        });        System.out.println("匿名内部类方式："+list);        //由于Comparator接口是一个函数式接口，因此根据jdk1.8新特性，我们可以采用Lambda表达式简化代码        Collections.sort(list,(u1,u2)->{
   return u1.getName().compareTo(u2.getName());});        System.out.println("Lambda表达式方式："+list);    }}
      
     
    
   

这里简单说一下什么是函数式接口，一般而言，函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。@FunctionalInterface：标明一个接口是一个函数式接口。 接口概述：

接口中的方法会被隐式的指定为  public abstract接口中的变量会被隐式的指定为  public static final

我们看一下上面Comparator使用到的Collections.sort的源码：

@SuppressWarnings({
   "unchecked", "rawtypes"}) public static 
   
     void sort(List
    
      list, Comparator
      c) {
        list.sort(c); }
    
   

第二个参数是 Comparator<? super T> c点进去可以看到如下：

发现他就是一个函数式接口，再看看compare方法要求(参数和返回值)，于是乎就可以使用Lambda表达式简化了。

参考来源：

1、

转载地址：https://dh-butterfly.blog.csdn.net/article/details/112731217 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！