【Java】Comparable和Comparator接口

简介: 【Java】Comparable和Comparator接口

一. Comparable接口

1. Comparable简介

Comparable是排序接口。

若一个类实现了Comparable接口,就意味着该类支持排序。

实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序。

Comparable接口的源码

public interface Comparable<T> {
        public int compareTo(T o);
}

2. 为什么要实现Comparable接口

一个类型实现了Compareable接口,表明了这个类具有了可排序的功能或者说标准,两个对象通过Compareable接口中的compareTo方法的返回值来比较大小。

首先定义一个学生对象, 再给定一个学生对象数组, 对这个对象数组中的元素进行排序(按年龄升序), 我们知道操作数组的工具包Arrays中有一个现成的 sort 方法可以给数组元素进行排序, 能否直接使用这个方法呢?

class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
        Student[] stu = {
                new Student("zhansan",18),
                new Student("lisi", 20),
                new Student("zhaoliu",15)
        };
        Arrays.sort(stu);
        System.out.println(Arrays.toString(stu));
    }
}

程序运行时出现了类型转换异常73d8c9be8b2a4960a39693770de0ac9a.png

此时去跳转到异常提示的位置查看,可以发现源码中是将数组元素强制转换为Comparable类型,再去调用其中的compareTo方法,而此时我们自定义类型Student与Comparable毫不相干,Student类中是没有compareTo方法的。image.png

再看一个例子,定义一个字符串数组将其排序后输出

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        String[] str = {"xin","abc","rong","def"};
        Arrays.sort(str);
        System.out.println(Arrays.toString(str));
    }
}

执行发现可以完成排序73d8c9be8b2a4960a39693770de0ac9a.png

再去观察String类的源码,可以发现String类也实现了Comparable接口重写了compareTo方法73d8c9be8b2a4960a39693770de0ac9a.pngd782482c79567a92bfcf9e29d83ee7e1.png

此时就可以理解实现Comparable接口的原因

3. Comparable的实际应用

理解了Comparable接口后再来实现 给对象数组排序

让 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法

在 sort 方法中会自动调用 compareTo 方法, compareTo 的参数是 Object , 其实传入的就是 Student 类的对象.

然后比较当前对象和参数对象的大小关系(按年龄来算). 如果当前对象应排在参数对象之前, 返回大于 0 的数字; 如果当前对象应排在参数对象之后, 返回小于于 0 的数字; 如果当前对象和参数对象不分先后, 返回 0; 再次执行程序, 结果就符合预期了.

import java.util.Arrays;
class Student implements Comparable<Student>{
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public int compareTo(Student o) {
        if (this.age == o.age){
            return 0;
        }else if (this.age < o.age){
            return -1;
        }else {
            return 1;
        }
    }
}
public class Test {
    public static void main(String[] args) {
        Student[] stu = {
                new Student("zhansan",18),
                new Student("lisi", 20),
                new Student("zhaoliu",15)
        };
        Arrays.sort(stu);
        System.out.println(Arrays.toString(stu));
    }
}

执行结果:73d8c9be8b2a4960a39693770de0ac9a.png

注意事项:

对于 sort 方法来说, 需要传入的数组的每个对象都是 “可比较” 的, 需要具备 compareTo 这样的能力. 通 过重写 compareTo 方法的方式, 就可以定义比较规则.

这里自己实现一个 sort 方法来完成排序过程(使用冒泡排序)

public static void bubbleSort(Comparable[] array) {
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j].compareTo(array[j+1]) > 0) {
                    Comparable tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp; 
                }
            }
        }
}

Comparator接口

1. Comparator简介

Comparator是比较接口,我们如果需要控制某个类的次序,而该类本身不支持排序(即没有实现Comparable接口),那么我们就可以建立一个“该类的比较器”来进行排序,这个“比较器”只需要实现Comparator接口即可。也就是说,我们可以通过实现Comparator来新建一个比较器,然后通过这个比较器对类进行排序。


Comparator接口源码:

public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
}

可以看到Comparator接口中包含两个抽象抽象方法,分别是为compare, equals,但类实现此接口时,只需要实现的接口只有compare方法即可;


Java中类都继承于Object类,而Object类默认实现了equals方法,所以类实现Comparator接口,实现类中不需要必须去实现equals方法,可以理解为虽然我们没有去实现,但实现类继承于Object类,相当于实现类中已经默认实现了equals方法

2. Comparator接口的实际运用

Arrays.sort()中有下面给出的重载,可以用来排序自定义类型

  • Arrays.sort(T[] a, Comparator<? super T> c);

此时的sort方法中的第二个参数我们传入一个实现了java.util.Comparator接口的实例,所以在排序自定义类型时可以定义一个比较器去实现


下面分别以以对象的name和age属性定义俩个比较器,分别以这两个比较器去实现排序


在以name进行比较时,实际上是以字符串进行比较,String类实现了Comparable接口,所以可以直接调用comparTo方法。

import java.util.Arrays;
import java.util.Comparator;
class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getAge() - o2.getAge();
    }
}
class NameComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getName().compareTo(o2.getName());
    }
}
class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student[] stu = {
                new Student("ghi",18),
                new Student("def", 15),
                new Student("abc",20)
        };
        System.out.println("以年龄进行排序");
        Arrays.sort(stu, new AgeComparator());
        System.out.println(Arrays.toString(stu));
        System.out.println("再以姓名进行排序");
        Arrays.sort(stu, new NameComparator());
        System.out.println(Arrays.toString(stu));
    }
}

执行结果:73d8c9be8b2a4960a39693770de0ac9a.png

下面的代码是使用比较器比较对象

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("xin",10);
        Student student2 = new Student("rong",40);
        AgeComparator ageComparator = new AgeComparator();
        if(ageComparator.compare(student1,student2) > 0) {
            System.out.println("student1 > student2");
        }else if(ageComparator.compare(student1,student2) == 0){
            System.out.println("student1 = student2");
        }else{
            System.out.println("student1 < student2");
        }
    }

执行结果:73d8c9be8b2a4960a39693770de0ac9a.png

三. Comparable和Comparator的比较

Comparable是排序接口,若一个类实现了Comparable接口,就意味着“该类支持排序”;而Comparator是比较器,我们若需要控制某个类的次序,可以建立一个“该类的比较器”来进行排序。

Comparable相当于“内部比较器”,而Comparator相当于“外部比较器”。

Comparable 对类的侵入性非常强, 一但投入使用便不方便再做修改,用起来比较简单,只要实现Comparable 接口的对象直接就成为一个可以比较的对象,需要重写comparTo方法,所以如果想要更换比较方式,就需要对comparTo “大动干戈”。

Comparator 对类的侵入性比较弱, 使用起来非常灵活,用Comparator实现一个比较器, 当某个自定义的对象需要作比较的时候,把比较器和对象一起传递过去就可以比大小了, 使用Comparator比较,如果想要更换比较方式,只需要在原来的基础上再增加一个比较器即可。


目录
相关文章
|
1月前
|
数据采集 JSON Java
Java爬虫获取1688店铺所有商品接口数据实战指南
本文介绍如何使用Java爬虫技术高效获取1688店铺商品信息,涵盖环境搭建、API调用、签名生成及数据抓取全流程,并附完整代码示例,助力市场分析与选品决策。
|
1月前
|
消息中间件 缓存 前端开发
从资损百万到零事故:Java 接口幂等设计的艺术与实践
在分布式系统中,重复请求常引发严重资损,如支付双扣、库存超卖等问题,其根源在于接口缺乏幂等性设计。本文通过真实案例揭示幂等性的重要性,并详解8种主流解决方案,涵盖唯一请求ID、乐观锁、悲观锁、状态机等,帮助开发者构建稳定系统,保障业务一致性。无论你是架构师还是开发工程师,都能从中获得实战指导,有效规避重复调用带来的风险。
137 0
|
1月前
|
存储 缓存 安全
Java集合框架(二):Set接口与哈希表原理
本文深入解析Java中Set集合的工作原理及其实现机制,涵盖HashSet、LinkedHashSet和TreeSet三大实现类。从Set接口的特性出发,对比List理解去重机制,并详解哈希表原理、hashCode与equals方法的作用。进一步剖析HashSet的底层HashMap实现、LinkedHashSet的双向链表维护顺序特性,以及TreeSet基于红黑树的排序功能。文章还包含性能对比、自定义对象去重、集合运算实战和线程安全方案,帮助读者全面掌握Set的应用与选择策略。
144 23
|
1月前
|
安全 Java 开发者
Java集合框架:详解Deque接口的栈操作方法全集
理解和掌握这些方法对于实现像浏览器后退功能这样的栈操作来说至关重要,它们能够帮助开发者编写既高效又稳定的应用程序。此外,在多线程环境中想保证线程安全,可以考虑使用ConcurrentLinkedDeque,它是Deque的线程安全版本,尽管它并未直接实现栈操作的方法,但是Deque的接口方法可以相对应地使用。
116 12
|
1月前
|
存储 安全 Java
Java集合框架(一):List接口及其实现类剖析
本文深入解析Java中List集合的实现原理,涵盖ArrayList的动态数组机制、LinkedList的链表结构、Vector与Stack的线程安全性及其不推荐使用的原因,对比了不同实现的性能与适用场景,帮助开发者根据实际需求选择合适的List实现。
|
1月前
|
Java API 网络架构
java调用api接口自动判断节假日信息
java调用api接口自动判断节假日信息
619 0
|
2月前
|
存储 安全 Java
深入理解Java序列化接口及其实现机制
记住,序列化不仅仅是把对象状态保存下来那么简单,它涉及到类的版本控制、安全性和性能等多个重要方面。正确理解和实现Java序列化机制对于构建高效、安全和可维护的Java应用至关重要。
111 0
|
3月前
|
安全 Java API
Java 抽象类与接口在 Java17 + 开发中的现代应用实践解析
《Java抽象类与接口核心技术解析》 摘要:本文全面剖析Java抽象类与接口的核心概念与技术差异。抽象类通过模板设计实现代码复用,支持具体方法与状态管理;接口则定义行为规范,实现多态支持。文章详细对比了两者在实例化、方法实现、继承机制等方面的区别,并提供了模板方法模式(抽象类)和策略模式(接口)的典型应用示例。特别指出Java8+新特性为接口带来的灵活性提升,包括默认方法和静态方法。最后给出最佳实践建议:优先使用接口定义行为规范,通过抽象类实现代码复用,合理组合两者构建灵活架构。
76 2
|
3月前
|
JSON Java 数据库连接