【高频面试题四】Comparator和Comparable的区别

区别：Comparable通常被类所实现，可以在类中重写compareTo方法实现排序
Comparator通常在类外使用，一般使用匿名内部类来实现比较器。
comparator接口是一个函数式接口和lamada表达式使用

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

package cn.lxx.test;
 
public class User implements Comparable<User> {   //该类实现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("ake", 25, true);
        User user2 = new User("reo", 24, false);
        User user3 = new User("fg", 24, false);
        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        Collections.sort(list);
        System.out.println("Comparable:" + list);
    }
}

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

 
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
 
public class User implements Comparator<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;
    }
 
    @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<User> list=new ArrayList<User>();
        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<User>() {
            @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);
    }
}

类自身实现Comparator:[User{name=‘reo’, age=24, sex=false}, User{name=‘fg’, age=24, sex=false}, User{name=‘ake’, age=25, sex=true}]

匿名内部类方式：[User{name=‘ake’, age=25, sex=true}, User{name=‘fg’, age=24, sex=false}, User{name=‘reo’, age=24, sex=false}]

Lambda表达式方式：[User{name=‘ake’, age=25, sex=true}, User{name=‘fg’, age=24, sex=false}, User{name=‘reo’, age=24, sex=false}]

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