面试官:元素排序Comparable和Comparator有什么区别?

开发 后端
在 Java 语言中,Comparable 和 Comparator 都是用来进行元素排序的,但二者有着本质的区别。它们两也是常见的面试题,所以今天我们一起来盘它。

 

[[439992]]

在 Java 语言中,Comparable 和 Comparator 都是用来进行元素排序的,但二者有着本质的区别。它们两也是常见的面试题,所以今天我们一起来盘它。

1.字面含义不同

我们先从二者的字面含义来理解它,Comparable 翻译为中文是“比较”的意思,而 Comparator 是“比较器”的意思。Comparable 是以 -able 结尾的,表示它自身具备着某种能力,而 Comparator 是以 -or 结尾,表示自身是比较的参与者,这是从字面含义先来理解二者的不同。

2.用法不同

二者都是顶级的接口,但拥有的方法和用法是不同的,下面我们分别来看。

2.1 Comparable

Comparable 接口只有一个方法 compareTo,实现 Comparable 接口并重写 compareTo 方法就可以实现某个类的排序了,它支持 Collections.sort 和 Arrays.sort 的排序。

在我们没有使用 Comparable 时,程序的执行是这样的:

  1. import lombok.Getter; 
  2. import lombok.Setter; 
  3. import lombok.ToString; 
  4.  
  5. import java.util.ArrayList; 
  6. import java.util.List; 
  7.  
  8. public class ComparableExample { 
  9.     public static void main(String[] args) { 
  10.         // 创建对象 
  11.         Person p1 = new Person(1, 18, "Java"); 
  12.         Person p2 = new Person(2, 22, "MySQL"); 
  13.         Person p3 = new Person(3, 6, "Redis"); 
  14.         // 添加到集合 
  15.         List<Person> list = new ArrayList<>(); 
  16.         list.add(p1); 
  17.         list.add(p2); 
  18.         list.add(p3); 
  19.         // 打印集合信息 
  20.         list.forEach(p -> System.out.println(p.getName() + 
  21.                 ":" + p.getAge())); 
  22.     } 
  23.  
  24. // 以下 set/get/toString 都使用的是 lombok 提供的注解 
  25. @Getter  
  26. @Setter 
  27. @ToString 
  28. class Person { 
  29.     private int id; 
  30.     private int age; 
  31.     private String name
  32.  
  33.     public Person(int id, int age, String name) { 
  34.         this.id = id; 
  35.         this.age = age; 
  36.         this.name = name
  37.     } 

程序执行结果如下:

从上图可以看出,当自定义类 Person 没有实现 Comparable 时,List 集合是没有排序的,只能以元素的插入顺序作为输出的顺序。

然而这个时候,老板有一个需求:需要根据 Person 对象的年龄 age 属性进行倒序,也就是根据 age 属性从大到小进行排序,这个时候就可以请出,我们本文的主角:Comparable 出场了。

Comparable 的使用是在自定义对象的类中实现 Comparable 接口,并重写 compareTo 方法来实现自定义排序规则的,具体实现代码如下:

  1. import lombok.Getter; 
  2. import lombok.Setter; 
  3. import lombok.ToString; 
  4.  
  5. import java.util.ArrayList; 
  6. import java.util.Collections; 
  7. import java.util.List; 
  8.  
  9. public class ComparableExample { 
  10.     public static void main(String[] args) { 
  11.         // 创建对象 
  12.         Person p1 = new Person(1, 18, "Java"); 
  13.         Person p2 = new Person(2, 22, "MySQL"); 
  14.         Person p3 = new Person(3, 6, "Redis"); 
  15.         // 添加对象到集合 
  16.         List<Person> list = new ArrayList<>(); 
  17.         list.add(p1); 
  18.         list.add(p2); 
  19.         list.add(p3); 
  20.         // 进行排序操作(根据 Person 类中 compareTo 中定义的排序规则) 
  21.         Collections.sort(list); 
  22.         // 输出集合中的顺序 
  23.         list.forEach(p -> System.out.println(p.getName() + 
  24.                 ":" + p.getAge())); 
  25.     } 
  26. //  以下 set/get/toString 都使用的是 lombok 提供的注解实现的 
  27. @Getter 
  28. @Setter 
  29. @ToString 
  30. static class Person implements Comparable<Person> { 
  31.     private int id; 
  32.     private int age; 
  33.     private String name
  34.  
  35.     public Person(int id, int age, String name) { 
  36.         this.id = id; 
  37.         this.age = age; 
  38.         this.name = name
  39.     } 
  40.  
  41.     @Override 
  42.     public int compareTo(Person p) { 
  43.         return p.getAge() - this.getAge(); 
  44.     } 

程序的执行结果如下图所示:

compareTo 排序方法说明

compareTo 方法接收的参数 p 是要对比的对象,排序规则是用当前对象和要对比的对象进行比较,然后返回一个 int 类型的值。正序从小到大的排序规则是:使用当前的对象值减去要对比对象的值;而倒序从大到小的排序规则刚好相反:是用对比对象的值减去当前对象的值。

注意事项:如果自定义对象没有实现 Comparable 接口,那么它是不能使用 Collections.sort 方法进行排序的,编译器会提示如下错误:图片

2.2 Comparator

Comparator 和 Comparable 的排序方法是不同的,Comparable 排序的方法是 compareTo,而 Comparator 排序的方法是 compare,具体实现代码如下:

  1. import lombok.Getter; 
  2. import lombok.Setter; 
  3.  
  4. import java.util.ArrayList; 
  5. import java.util.Collections; 
  6. import java.util.Comparator; 
  7. import java.util.List; 
  8.  
  9. public class ComparatorExample { 
  10.     public static void main(String[] args) { 
  11.         // 创建对象 
  12.         Person p1 = new Person(1, 18, "Java"); 
  13.         Person p2 = new Person(2, 22, "MySQL"); 
  14.         Person p3 = new Person(3, 6, "Redis"); 
  15.         // 添加对象到集合 
  16.         List<Person> list = new ArrayList<>(); 
  17.         list.add(p1); 
  18.         list.add(p2); 
  19.         list.add(p3); 
  20.         // 进行排序操作(根据 PersonComparator 中定义的排序规则) 
  21.         Collections.sort(list, new PersonComparator()); 
  22.         // 输出集合中的顺序 
  23.         list.forEach(p -> System.out.println(p.getName() + 
  24.                 ":" + p.getAge())); 
  25.     } 
  26. /** 
  27.   * 用于 Person 类的比较器 
  28.   */ 
  29. class PersonComparator implements Comparator<Person> { 
  30.     @Override 
  31.     public int compare(Person p1, Person p2) { 
  32.         return p2.getAge() - p1.getAge(); 
  33.     } 
  34. @Getter 
  35. @Setter 
  36. class Person { 
  37.     private int id; 
  38.     private int age; 
  39.     private String name
  40.  
  41.     public Person(int id, int age, String name) { 
  42.         this.id = id; 
  43.         this.age = age; 
  44.     } 

程序的执行结果如下图所示:

扩展:Comparator 匿名类

Comparator 除了可以通过创建自定义比较器外,还可以通过匿名类的方式,更快速、便捷的完成自定义比较器的功能,具体的代码实现如下:

  1. import lombok.Getter; 
  2. import lombok.Setter; 
  3.  
  4. import java.util.ArrayList; 
  5. import java.util.Comparator; 
  6. import java.util.List; 
  7.  
  8. public class ComparatorExample { 
  9.     public static void main(String[] args) { 
  10.         // 构建并添加数据 
  11.         List<Person> list = new ArrayList<>(); 
  12.         list.add(new Person(1, 18, "Java")); 
  13.         list.add(new Person(2, 20, "MySQL")); 
  14.         list.add(new Person(3, 6, "Redis")); 
  15.         // 使用 Comparator 匿名类的方式进行排序 
  16.         list.sort(new Comparator<Person>() { 
  17.             @Override 
  18.             public int compare(Person p1, Person p2) { 
  19.                 return p2.getAge() - p1.getAge(); 
  20.             } 
  21.         }); 
  22.         // 打印集合数据 
  23.         list.forEach(p -> System.out.println(p.getName() + 
  24.                 ":" + p.getAge())); 
  25.     } 
  26.  
  27. @Getter 
  28. @Setter 
  29. static class Person { 
  30.     private int id; 
  31.     private int age; 
  32.     private String name
  33.  
  34.     public Person(int id, int age, String name) { 
  35.         this.id = id; 
  36.         this.age = age; 
  37.         this.name = name
  38.     } 

程序的执行结果如下图所示:

3.使用的场景不同

通过上面示例的实现代码我们可以看出,使用 Comparable 必须要修改原有的类,也就是你要排序那个类,就要在那个中实现 Comparable 接口并重写 compareTo 方法,所以 Comparable 更像是“对内”进行排序的接口。

而 Comparator 的使用则不相同,Comparator 无需修改原有类。也就是在最极端情况下,即使 Person 类是第三方提供的,我们依然可以通过创建新的自定义比较器 Comparator,来实现对第三方类 Person 的排序功能。也就是说通过 Comparator 接口可以实现和原有类的解耦,在不修改原有类的情况下实现排序功能,所以 Comparator 可以看作是“对外”提供排序的接口。

总结

Comparable 和 Comparator 都是用来实现元素排序的,它们二者的区别如下:

Comparable 是“比较”的意思,而 Comparator 是“比较器”的意思;

Comparable 是通过重写 compareTo 方法实现排序的,而 Comparator 是通过重写 compare 方法实现排序的;

Comparable 必须由自定义类内部实现排序方法,而 Comparator 是外部定义并实现排序的。

所以用一句话总结二者的区别:Comparable 可以看作是“对内”进行排序接口,而 Comparator 是“对外”进行排序的接口。

是非审之于己,毁誉听之于人,得失安之于数。

博主介绍:80 后程序员,写博客这件事“坚持”了 12 年了,爱好:读书、慢跑、羽毛球。

本文转载自微信公众号「Java面试真题解析」,可以通过以下二维码关注。转载本文请联系Java面试真题解析公众号。

 

责任编辑:武晓燕 来源: Java面试真题解析
相关推荐

2023-02-17 08:10:24

2021-12-10 12:01:37

finalfinallyfinalize

2021-11-30 07:44:50

FinalFinallyFinalize

2021-12-23 07:11:31

开发

2024-03-20 15:12:59

KafkaES中间件

2023-07-11 08:40:02

IO模型后台

2023-02-09 07:01:35

转发重定向Java

2024-03-26 16:24:46

分布式事务2PC3PC

2023-02-20 07:19:14

2023-12-13 13:31:00

useEffect对象浏览器

2022-05-16 11:04:43

RocketMQPUSH 模式PULL 模式

2021-12-27 06:57:40

This SuperJava

2023-12-05 09:33:08

分布式事务

2021-09-30 07:57:13

排序算法面试

2021-05-10 08:01:12

BeanFactoryFactoryBean容器

2022-08-22 07:06:32

MyBatisSQL占位符

2021-07-08 06:51:29

React函数组件

2022-08-03 07:04:56

GETHTTPPOST

2022-04-24 07:59:53

synchronizJVMAPI

2022-08-10 07:06:57

IoCDISpring
点赞
收藏

51CTO技术栈公众号