目录
  • 1.字面含义不同
  • 2.用法不同
    • 2.1 Comparable
    • 2.2 compareTo 排序方法说明
    • 2.3 Comparator
  • 3.扩展:Comparator 匿名类
    • 4.使用的场景不同
      • 总结

        两者比较结构图:

        Java元素排序Comparable与Comparator的区别

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

        1.字面含义不同

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

        2.用法不同

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

        2.1 Comparable

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

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

        import lombok.Getter;
        import lombok.Setter;
        import lombok.ToString;
        import java.util.ArrayList;
        import java.util.List;
        public class ComparableExample {
            public static void main(String[] args) {
                // 创建对象
                Person p1 = new Person(1, 18, "Java");
                Person p2 = new Person(2, 22, "MySQL");
                Person p3 = new Person(3, 6, "Redis");
                // 添加到集合
                List<Person> list = new ArrayList<>();
                list.add(p1);
                list.add(p2);
                list.add(p3);
                // 打印集合信息
                list.forEach(p -> System.out.println(p.getName() +
                        ":" + p.getAge()));
            }
        }
        // 以下 set/get/toString 都使用的是 lombok 提供的注解
        @Getter 
        @Setter
        @ToString
        class Person {
            private int id;
            private int age;
            private String name;
        
            public Person(int id, int age, String name) {
                this.id = id;
                this.age = age;
                this.name = name;
            }
        }

        程序执行结果如下: 

        Java元素排序Comparable与Comparator的区别

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

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

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

        import lombok.Getter;
        import lombok.Setter;
        import lombok.ToString;
        import java.util.ArrayList;
        import java.util.Collections;
        import java.util.List;
        public class ComparableExample {
            public static void main(String[] args) {
                // 创建对象
                Person p1 = new Person(1, 18, "Java");
                Person p2 = new Person(2, 22, "MySQL");
                Person p3 = new Person(3, 6, "Redis");
                // 添加对象到集合
                List<Person> list = new ArrayList<>();
                list.add(p1);
                list.add(p2);
                list.add(p3);
                // 进行排序操作(根据 Person 类中 compareTo 中定义的排序规则)
                Collections.sort(list);
                // 输出集合中的顺序
                list.forEach(p -> System.out.println(p.getName() +
                        ":" + p.getAge()));
            }
        }
        //  以下 set/get/toString 都使用的是 lombok 提供的注解实现的
        @Getter
        @Setter
        @ToString
        static class Person implements Comparable<Person> {
            private int id;
            private int age;
            private String name;
            public Person(int id, int age, String name) {
                this.id = id;
                this.age = age;
                this.name = name;
            }
            @Override
            public int compareTo(Person p) {
                return p.getAge() - this.getAge();
            }
        }

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

        Java元素排序Comparable与Comparator的区别

        2.2 compareTo 排序方法说明

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

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

        Java元素排序Comparable与Comparator的区别

        2.3 Comparator

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

        import lombok.Getter;
        import lombok.Setter;
        import java.util.ArrayList;
        import java.util.Collections;
        import java.util.Comparator;
        import java.util.List;
        public class ComparatorExample {
            public static void main(String[] args) {
                // 创建对象
                Person p1 = new Person(1, 18, "Java");
                Person p2 = new Person(2, 22, "MySQL");
                Person p3 = new Person(3, 6, "Redis");
                // 添加对象到集合
                List<Person> list = new ArrayList<>();
                list.add(p1);
                list.add(p2);
                list.add(p3);
                // 进行排序操作(根据 PersonComparator 中定义的排序规则)
                Collections.sort(list, new PersonComparator());
                // 输出集合中的顺序
                list.forEach(p -> System.out.println(p.getName() +
                        ":" + p.getAge()));
            }
        }
        /**
          * 用于 Person 类的比较器
          */
        class PersonComparator implements Comparator<Person> {
            @Override
            public int compare(Person p1, Person p2) {
                return p2.getAge() - p1.getAge();
            }
        }
        @Getter
        @Setter
        class Person {
            private int id;
            private int age;
            private String name;
        
            public Person(int id, int age, String name) {
                this.id = id;
                this.age = age;
            }
        }

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

        Java元素排序Comparable与Comparator的区别

        3.扩展:Comparator 匿名类

        Comparator 除了可以通过创建自定义比较器外,还可以通过匿名类的方式,更快速、便捷的完成自定义比较器的功能,

        具体的代码实现如下:

        import lombok.Getter;
        import lombok.Setter;
        import java.util.ArrayList;
        import java.util.Comparator;
        import java.util.List;
        public class ComparatorExample {
            public static void main(String[] args) {
                // 构建并添加数据
                List<Person> list = new ArrayList<>();
                list.add(new Person(1, 18, "Java"));
                list.add(new Person(2, 20, "MySQL"));
                list.add(new Person(3, 6, "Redis"));
                // 使用 Comparator 匿名类的方式进行排序
                list.sort(new Comparator<Person>() {
                    @Override
                    public int compare(Person p1, Person p2) {
                        return p2.getAge() - p1.getAge();
                    }
                });
                // 打印集合数据
                list.forEach(p -> System.out.println(p.getName() +
                        ":" + p.getAge()));
            }
        }
        @Getter
        @Setter
        static class Person {
            private int id;
            private int age;
            private String name;
        
            public Person(int id, int age, String name) {
                this.id = id;
                this.age = age;
                this.name = name;
            }
        }

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

        Java元素排序Comparable与Comparator的区别

        4.使用的场景不同

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

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

        总结

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

        • Comparable 是“比较”的意思,而 Comparator 是“比较器”的意思;
        • Comparable 是通过重写 compareTo 方法实现排序的,而 Comparator 是通过重写 compare 方法实现排序的;
        • Comparable 必须由自定义类内部实现排序方法,而 Comparator 是外部定义并实现排序的。

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

        声明:本站所有文章,如无特殊说明或标注,均为本站原创发布。任何个人或组织,在未征得本站同意时,禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益,可联系我们进行处理。