原创文章,转载请标注出处:《Java基础系列-Comparable和Comparator》

一、概述

        Java中的排序是由Comparable和Comparator这两个接口来提供的。

        Comparable表示可被排序的,实现该接口的类的对象自动拥有排序功能。

        Comparator则表示一个比较器,实现了该接口的的类的对象是一个针对目标类的对象定义的比较器,一般情况,这个比较器将作为一个参数进行传递。

二、Comparable

        Comparable的中文意思就是可被排序的,代表本身支持排序功能。只要我们的类实现了这个接口,那么这个类的对象就会自动拥有了可被排序的能力。而且这个排序被称为类的自然顺序。这个类的对象的列表可以被Collections.sort和Arrays.sort来执行排序。同时这个类的实例具备作为sorted map的key和sorted set的元素的资格。

        假如a和b都是实现了Comparable接口的类C的实例,那么只有当a.compareTo(b)的结果与a.equals(b)的结果一致时,才称类C的自然顺序与equals一致。强烈建议将类的自然顺序和equals的结果保持一致,因为如果不一致的话,由该类对象为键的sorted map和由该类对象为元素的sorted set的行为将会变得很怪异。

        例如对于一个实现了Comparable接口的元素的有序集合sorted set而言,如果a.equals(b)结果为false,并且a.compareTo(b)==0,则第二个元素的添加操作将会失败,因为在sorted set看来,二者在排序上是一致的,它不报保存重复的元素。

        事实上,Java中的类基本都是自然顺序与equals一致的,除了BigDecimal,因为BigDecimal中的自然顺序和值相同但精度不同的元素(例如4和4.00)的equals均一致。

源码解析

  1. public interface Comparable<T> {
  2. public int compareTo(T o);
  3. }

        从源码中可以看到,该接口只有一个抽象方法compareTo,这个方法主要就是为了定义我们的类所要排序的方式。compareTo方法用于比较当前元素a与指定元素b,结果为int值,如果a > b,int>0;如果a=b,int=0;如果a<b,int<0。

三、Comparator

        Comparator中文译为比较器,它可以作为一个参数传递到Collections.sort和Arrays.sort方法来指定某个类对象的排序方式。同时它也能为sorted set和sorted map指定排序方式。

        同Comparable类似,指定比较器的时候一般也要保证比较的结果与equals结果一致,不一致的话,对应的sorted set和sorted map的行为同样会变得怪异。

        推荐实现的比较器类同时实现java.io.Serializable接口,以拥有序列化能力,因为它可能会被用作序列化的数据结构(TreeSet、TreeMap)的排序方法。

源码解析

  1. @FunctionalInterface
  2. public interface Comparator<T> {
  3. // 唯一的抽象方法,用于定义比较方式(即排序方式)
  4. // o1>o2,返回1;o1=o2,返回0;o1<o2,返回-1
  5. int compare(T o1, T o2);
  6. boolean equals(Object obj);
  7. // 1.8新增的默认方法:用于反序排列
  8. default Comparator<T> reversed() {
  9. return Collections.reverseOrder(this);
  10. }
  11. // 1.8新增的默认方法:用于构建一个次级比较器,当前比较器比较结果为0,则使用次级比较器比较
  12. default Comparator<T> thenComparing(Comparator<? super T> other) {
  13. Objects.requireNonNull(other);
  14. return (Comparator<T> & Serializable) (c1, c2) -> {
  15. int res = compare(c1, c2);
  16. return (res != 0) ? res : other.compare(c1, c2);
  17. };
  18. }
  19. // 1.8新增默认方法:指定次级比较器的
  20. // keyExtractor表示键提取器,定义提取方式
  21. // keyComparator表示键比较器,定义比较方式
  22. default <U> Comparator<T> thenComparing(
  23. Function<? super T, ? extends U> keyExtractor,
  24. Comparator<? super U> keyComparator)
  25. {
  26. return thenComparing(comparing(keyExtractor, keyComparator));
  27. }
  28. // 1.8新增默认方法:用于执行键的比较,采用的是由键对象内置的比较方式
  29. default <U extends Comparable<? super U>> Comparator<T> thenComparing(
  30. Function<? super T, ? extends U> keyExtractor)
  31. {
  32. return thenComparing(comparing(keyExtractor));
  33. }
  34. // 1.8新增默认方法:用于比较执行int类型的键的比较
  35. default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {
  36. return thenComparing(comparingInt(keyExtractor));
  37. }
  38. // 1.8新增默认方法:用于比较执行long类型的键的比较
  39. default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {
  40. return thenComparing(comparingLong(keyExtractor));
  41. }
  42. // 1.8新增默认方法:用于比较执行double类型的键的比较
  43. default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {
  44. return thenComparing(comparingDouble(keyExtractor));
  45. }
  46. // 1.8新增静态方法:用于得到一个相反的排序的比较器,这里针对的是内置的排序方式(即继承Comparable)
  47. public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
  48. return Collections.reverseOrder();
  49. }
  50. // 1.8新增静态方法:用于得到一个实现了Comparable接口的类的比较方式的比较器
  51. // 简言之就是将Comparable定义的比较方式使用Comparator实现
  52. @SuppressWarnings("unchecked")
  53. public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
  54. return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
  55. }
  56. // 1.8新增静态方法:得到一个null亲和的比较器,null小于非null,两个null相等,如果全不是null,
  57. // 则使用指定的比较器比较,若未指定比较器,则非null全部相等返回0
  58. public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
  59. return new Comparators.NullComparator<>(true, comparator);
  60. }
  61. // 1.8新增静态方法:得到一个null亲和的比较器,null大于非null,两个null相等,如果全不是null,
  62. // 则使用指定的比较器比较,若未指定比较器,则非null全部相等返回0
  63. public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
  64. return new Comparators.NullComparator<>(false, comparator);
  65. }
  66. // 1.8新增静态方法:使用指定的键比较器用于执行键的比较
  67. public static <T, U> Comparator<T> comparing(
  68. Function<? super T, ? extends U> keyExtractor,
  69. Comparator<? super U> keyComparator)
  70. {
  71. Objects.requireNonNull(keyExtractor);
  72. Objects.requireNonNull(keyComparator);
  73. return (Comparator<T> & Serializable)
  74. (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
  75. keyExtractor.apply(c2));
  76. }
  77. // 1.8新增静态方法:执行键比较,采用内置比较方式,key的类必须实现Comparable
  78. public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
  79. Function<? super T, ? extends U> keyExtractor)
  80. {
  81. Objects.requireNonNull(keyExtractor);
  82. return (Comparator<T> & Serializable)
  83. (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
  84. }
  85. // 1.8新增静态方法:用于int类型键的比较
  86. public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
  87. Objects.requireNonNull(keyExtractor);
  88. return (Comparator<T> & Serializable)
  89. (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
  90. }
  91. // 1.8新增静态方法:用于long类型键的比较
  92. public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) {
  93. Objects.requireNonNull(keyExtractor);
  94. return (Comparator<T> & Serializable)
  95. (c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));
  96. }
  97. // 1.8新增静态方法:用于double类型键的比较
  98. public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor) {
  99. Objects.requireNonNull(keyExtractor);
  100. return (Comparator<T> & Serializable)
  101. (c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
  102. }
  103. }

        老版本的Comparator中只要两个方法,就是前两个方法,后面的所有默认方法均为1.8新增的方法,采用的是1.8新增的功能:接口可添加默认方法。即便拥有如此多方法,该接口还是函数式接口,compare用于定义比较方式。

四、二者比较

        Comparable可以看做是内部比较器,Comparator可以看做是外部比较器。

        一个类,可以通过实现Comparable接口来自带有序性,也可以通过额外指定Comparator来附加有序性。

        二者的作用其实是一致的,所以不要混用。

        我们看个例子吧:

        首先定义个模型:User

  1. public class User implements Serializable, Comparable<User> {
  2. private static final long serialVersionUID = 1L;
  3. private int age;
  4. private String name;
  5. public User (){}
  6. public User (int age, String name){
  7. this.age = age;
  8. this.name = name;
  9. }
  10. public int getAge() {
  11. return age;
  12. }
  13. public void setAge(int age) {
  14. this.age = age;
  15. }
  16. public String getName() {
  17. return name;
  18. }
  19. public void setName(String name) {
  20. this.name = name;
  21. }
  22. @Override
  23. public int compareTo(User o) {
  24. return this.age - o.age;
  25. }
  26. @Override
  27. public String toString() {
  28. return "[user={age=" + age + ",name=" + name + "}]";
  29. }
  30. }

        在定义一个Comparator实现类MyComparator

  1. public class MyComparator implements Comparator<User> {
  2. @Override
  3. public int compare(User o1, User o2) {
  4. return o1.getName().charAt(0)-o2.getName().charAt(0);
  5. }
  6. }

        最后是测试类:Main

  1. public class Main {
  2. public static void main(String[] args) {
  3. User u1 = new User(12, "xiaohua");
  4. User u2 = new User(10, "abc");
  5. User u3 = new User(15,"ccc");
  6. User[] users = {u1,u2,u3};
  7. System.out.print("数组排序前:");
  8. printArray(users);
  9. System.out.println();
  10. Arrays.sort(users);
  11. System.out.print("数组排序1后:");
  12. printArray(users);
  13. System.out.println();
  14. Arrays.sort(users, new MyComparator());
  15. System.out.print("数组排序2后:");
  16. printArray(users);
  17. System.out.println();
  18. Arrays.sort(users, Comparator.reverseOrder());// 针对内置的排序进行倒置
  19. System.out.print("数组排序3后:");
  20. printArray(users);
  21. }
  22. public static void printArray (User[] users) {
  23. for (User user:users) {
  24. System.out.print(user.toString());
  25. }
  26. }
  27. }

        运行结果为:

  1. 数组排序前:[user={age=12,name=xiaohua}][user={age=10,name=abc}][user={age=15,name=ccc}]
  2. 数组排序1后:[user={age=10,name=abc}][user={age=12,name=xiaohua}][user={age=15,name=ccc}]
  3. 数组排序2后:[user={age=10,name=abc}][user={age=15,name=ccc}][user={age=12,name=xiaohua}]
  4. 数组排序3后:[user={age=15,name=ccc}][user={age=12,name=xiaohua}][user={age=10,name=abc}]

        通过上面的例子我们有一个结论,那就是两种方式定义排序的优先级,明显Comparator比较器要优先于内部排序Comparable。

五、总结

  • Comparable为可排序的,实现该接口的类的对象自动拥有可排序功能。
  • Comparator为比较器,实现该接口可以定义一个针对某个类的排序方式。
  • Comparator与Comparable同时存在的情况下,前者优先级高。

参考:

Java基础系列-Comparable和Comparator的更多相关文章

  1. Java基础之Comparable与Comparator

    Java基础之Comparable与Comparator 一.前言: Java中实现对对象的排序一般情况下主要有以下两种实现方式(万物皆对象嘛): 对象所在的类实现Comparable 接口 定义比较 ...

  2. 面试----java基础集合---------------------comparable和comparator 的区别

    comparable接口     是主要是用来自定义类存储在主要是TreeSet,TreeMap(键)集合中存储时,自定通过实现这种接口得到自然排序的功能. comparator 接口  是主要是用来 ...

  3. Java基础系列-ArrayList

    原创文章,转载请标注出处:<Java基础系列-ArrayList> 一.概述 ArrayList底层使用的是数组.是List的可变数组实现,这里的可变是针对List而言,而不是底层数组. ...

  4. Java基础系列-equals方法和hashCode方法

    原创文章,转载请标注出处:<Java基础系列-equals方法和hashCode方法> 概述         equals方法和hashCode方法都是有Object类定义的. publi ...

  5. 夯实Java基础系列1:Java面向对象三大特性(基础篇)

    本系列文章将整理到我在GitHub上的<Java面试指南>仓库,更多精彩内容请到我的仓库里查看 [https://github.com/h2pl/Java-Tutorial](https: ...

  6. 夯实Java基础系列3:一文搞懂String常见面试题,从基础到实战,更有原理分析和源码解析!

    目录 目录 string基础 Java String 类 创建字符串 StringDemo.java 文件代码: String基本用法 创建String对象的常用方法 String中常用的方法,用法如 ...

  7. 夯实Java基础系列14:深入理解Java枚举类

    目录 初探枚举类 枚举类-语法 枚举类的具体使用 使用枚举类的注意事项 枚举类的实现原理 枚举类实战 实战一无参 实战二有一参 实战三有两参 枚举类总结 枚举 API 总结 参考文章 微信公众号 Ja ...

  8. Java基础系列2:深入理解String类

    Java基础系列2:深入理解String类 String是Java中最为常用的数据类型之一,也是面试中比较常被问到的基础知识点,本篇就聊聊Java中的String.主要包括如下的五个内容: Strin ...

  9. 2015年12月28日 Java基础系列(六)流

    2015年12月28日 Java基础系列(六)流2015年12月28日 Java基础系列(六)流2015年12月28日 Java基础系列(六)流

随机推荐

  1. BZOJ_4128_Matrix_矩阵乘法+哈希+BSGS

    BZOJ_4128_Matrix_矩阵乘法+哈希+BSGS Description 给定矩阵A,B和模数p,求最小的x满足 A^x = B (mod p) Input 第一行两个整数n和p,表示矩阵的 ...

  2. 【爆料】-《西澳大学毕业证书》UWA一模一样原件

    ☞西澳大学毕业证书[微/Q:2544033233◆WeChat:CC6669834]UC毕业证书/联系人Alice[查看点击百度快照查看][留信网学历认证&博士&硕士&海归&a ...

  3. C语言实现十六进制字符串转数字

    代码: int StringToInt(char *hex) { ]) * + CharToInt(hex[]); } int CharToInt(char hex) { ') '; if (hex& ...

  4. java happens-before原则规则

    程序次序规则:一个线程内,按照代码顺序,书写在前面的操作先行发生于书写在后面的操作: 锁定规则:一个unLock操作先行发生于后面对同一个锁额lock操作: volatile变量规则:对一个变量的写操 ...

  5. Django:Python3.6.2+Django2.0配置MySQL

    持续学习Django中... Django默认使用的数据库是python自带的SQLlite3,但SQLlite并不适用于大型的项目,因此我将数据库换成了MySQL,下面介绍下Django如何配置数据 ...

  6. C#判断字符串是不是英文或数字

    利用正则.   u4e00-u9fa5; //中文  ^[A-Za-z]+$  //英文字母 //截取冲击式样形状 public string SubStringForXingZhuang(strin ...

  7. Spring Boot入门(四):开发Web Api接口常用注解总结

    本系列博客记录自己学习Spring Boot的历程,如帮助到你,不胜荣幸,如有错误,欢迎指正! 在程序员的日常工作中,Web开发应该是占比很重的一部分,至少我工作以来,开发的系统基本都是Web端访问的 ...

  8. .net mvc + layui做图片上传(二)—— 使用流上传和下载图片

    摘要:上篇文章写到一种上传图片的方法,其中提到那种方法的局限性,就是上传的文件只能保存在本项目目录下,在其他目录中访问不到该文件.这与浏览器的安全性机制有关,浏览器不允许用户用任意的路径访问服务器上的 ...

  9. SQLite新建数据库及txt文件(CSV文件)导入

    1.安装准备: Windows系统环境: 安装:SQLiteExpert  及 官网的SQLite tool  我们要用到其中的SQLite.exe       地址:https://www.sqli ...

  10. 一、redis简单配置

    1.安装 下载安装后解压即可执行make命令完成编译,完整命令如下: wget http://download.redis.io/redis-stable.tar.gz tar xzf redis-s ...