Comparable接口和Comparator接口的使用和区别

最新推荐文章于 2025-05-15 15:17:57 发布
最新推荐文章于 2025-05-15 15:17:57 发布
阅读量3.3w 收藏 314
点赞数 65
CC 4.0 BY-SA版权
分类专栏： Java # 基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/IT_10/article/details/104747173

Comparable

Comparable接口在JDK8中的源码：

package java.lang;
import java.util.*;

package java.lang;
public interface Comparable<T> {
    public int compareTo(T o);
}

用法：

public class User implements Comparable<User>{
    private Integer id;
    private Integer age;

    public User() {
    }

    public User(Integer id, Integer age) {
        this.id = id;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                '}';
    }

    public int compareTo(User o) {
        if(this.age > o.getAge()) {
            return 1;
        }else if(this.age < o.getAge()) {
            return -1;
        }else{
            return 0;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        User user1 = new User(1, 14);
        User user2 = new User(2, 12);
        User user3 = new User(3, 10);
        User[] users = {user1, user2, user3};
        Arrays.sort(users);
        Arrays.stream(users).forEach(System.out::println);
    }
}

int compareTo(T o)

比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

参数： o - 要比较的对象。

返回：负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。

抛出：ClassCastException - 如果指定对象的类型不允许它与此对象进行比较

Comparator

Comparator接口在JDK8中的源码：

package java.util;

import java.io.Serializable;
import java.util.function.Function;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.function.ToDoubleFunction;
import java.util.Comparators;

public interface Comparator<T> {
	int compare(T o1, T o2);
	//还有很多其他方法...
}

使用：

public class Child {
    private Integer id;
    private Integer age;

    public Child() {
    }

    public Child(Integer id, Integer age) {
        this.id = id;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Child{" +
                "id=" + id +
                ", age=" + age +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
        Child child1 = new Child(1, 14);
        Child child2 = new Child(2, 12);
        Child child3 = new Child(3, 10);

        List<Child> list = new ArrayList<>();
        list.add(child1);
        list.add(child2);
        list.add(child3);

        Collections.sort(list, new Comparator<Child>() {
            @Override
            public int compare(Child o1, Child o2) {
                return  o1.getAge() > o2.getAge() ? 1 : (o1.getAge() == o2.getAge() ? 0 : -1);
            }
        });

        // 或者使用JDK8中的Lambda表达式
        //Collections.sort(list, (o1, o2) -> (o1.getAge()-o2.getAge()));

        list.stream().forEach(System.out::println);
    }
}

或者也可以通过实现的方式使用Comparator接口：

import java.util.Comparator;

public class Child implements Comparator<Child> {
    private Integer id;
    private Integer age;

    public Child() {
    }

    public Child(Integer id, Integer age) {
        this.id = id;
        this.age = age;
    }

    @Override
    public int compare(Child o1, Child o2) {
        return o1.getAge() > o2.getAge() ? 1 : (o1.getAge() == o2.getAge() ? 0 : -1);
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Child{" +
                "id=" + id +
                ", age=" + age +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
        Child child1 = new Child(1, 14);
        Child child2 = new Child(2, 12);
        Child child3 = new Child(3, 10);

        List<Child> list = new ArrayList<>();
        list.add(child1);
        list.add(child2);
        list.add(child3);
        
        Collections.sort(list, new Child());
        list.stream().forEach(System.out::println);
    }
}
Comparator接口其他默认方法的用法

reversed方法

default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }

这个方法是用来生成一个逆序器,比如我们开始需要得到一个正序的排序序列,然后又想得到一个反转的排序序列,就可以使用该方法。比如：

public class Test {
    public static void main(String[] args) {
        Child child1 = new Child(1, 14);
        Child child2 = new Child(2, 12);
        Child child3 = new Child(5, 10);
        Child child4 = new Child(4, 10);

        List<Child> list = new ArrayList<>();
        list.add(child1);
        list.add(child2);
        list.add(child3);
        list.add(child4);

        Comparator<Child> comparator = Comparator.comparingInt(x -> x.getAge());
        Collections.sort(list, comparator);
        list.stream().forEach(System.out::println);
        Collections.sort(list, comparator.reversed());
        list.stream().forEach(System.out::println);
    }
}

thenComparing

default <U extends Comparable<? super U>> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        return thenComparing(comparing(keyExtractor));
    }

该方法是在原有的比较器上再加入一个比较器，比如先按照年龄排序，年龄相同的在按照id排序。比如：

public class Test {
    public static void main(String[] args) {
        Child child1 = new Child(1, 14);
        Child child2 = new Child(2, 12);
        Child child3 = new Child(5, 10);
        Child child4 = new Child(4, 10);

        List<Child> list = new ArrayList<>();
        list.add(child1);
        list.add(child2);
        list.add(child3);
        list.add(child4);

        Comparator<Child> comparator = Comparator.comparingInt(x -> x.getAge());
        Collections.sort(list, comparator);
        list.stream().forEach(System.out::println);
        System.out.println("-----");
        Collections.sort(list, comparator.thenComparing(x->x.getId()));
        list.stream().forEach(System.out::println);
    }
}

Comparable接口和Comparator接口的区别

  • Comparable接口位于java.lang包下；Comparator位于java.util包下
  • Comparable接口只提供了一个compareTo()方法；Comparator接口不仅提供了compara()方法，还提供了其他默认方法，如reversed()、thenComparing()，使我们可以按照更多的方式进行排序
  • 如果要用Comparable接口，则必须实现这个接口，并重写comparaTo()方法；但是Comparator接口可以在类外部使用，通过将该接口的一个匿名类对象当做参数传递给Collections.sort()方法或者Arrays.sort()方法实现排序。Comparator体现了一种策略模式，即可以不用要把比较方法嵌入到类中，而是可以单独在类外部使用，这样我们就可有不用改变类本身的代码而实现对类对象进行排序。
Java中Comparable接口和Comparator接口怎么用？
小贺想改变
10-11 1145
Java中Comparable接口和Comparator接口怎么用？
Comparable接口和Comparator接口
桐花思雨
12-06 833
目录前言`Comparable` 接口 前言 在实际应用中，我们往往有需要 比较两个自定义对象 大小的地方。而这些自定义对象的比较，就不像简单的整型数据那么简单，它们往往包含有许多的属性，我们一般都是根据这些属性对自定义对象进行比较的。所以 Java 中要 比较对象的大小 或者要 对对象的集合 进行排序，需要通过比较这些对象的某些属性的大小来确定它们之间的大小关系 一般 Java 中通过接口来实现两个对象的比较，比较常用就是 Comparable 接口和Comparator 接口 Comparable 接口
java比较器Comparable接口和Comaprator接口
热门推荐
帅性而为1号的博客
06-25 3万+
java的比较器有两类，分别是Comparable接口和Comparator接口。 在为对象数组进行排序时，比较器的作用非常明显，首先来讲解Comparable接口。 让需要进行排序的对象实现Comparable接口，重写其中的compareTo(T o)方法，在其中定义排序规则，那么就可以直接调用java.util.Arrays.sort()来排序对象数组，实例如下： View Cod
Comparator 比较器
最新发布
LiLiYuan.的博客
05-15 862
假设存在。
Comparable和Comparator接口
小S的博客
11-19 792
Comparable和Comparator接口都可以用于自定义对象之间的比较排序，不同的是，使用Comparable接口必须操作比较类，需要覆写compareTo方法，这样当使用第三方提供的类进行对象的排序时，就很难进行操作；而使用Comparator接口可以不用再操作比较类而通过匿名内部类覆写compare方法实现比较对象的排序。所以Comparable更像是“对内”进行排序的接口，而Compator比较器实现了与比较类d额解耦，在不修改比较类的同时实现排序，因此更像是。
Comparable接口与Comparator接口
qq_43185543的博客
10-09 531
Comparable接口与Comparator接口 1.Comparable（内部排序接口） 若一个类实现了Comparable接口，就意味着“该类支持排序”。既然实现Comparable接口的类支持排序，假设现在存在“实现Comparable接口的类的对象的List列表（或数组）”，则该List列表（或数组）可以通过Collections.sort（或Arrays.sort)进行排序。 此外，“...
Comparable<T> 和 Comparator<T> 接口的比较
Allocator的优快云博客
09-07 565
背景 Comparable equals compareTo Comparator 小结 背景 最近在看Java 函数式编程的时候又看到了Comparator&amp;lt;T&amp;gt; 这个接口. 于是花了点时间把它的功能, 使用范围以及其”近亲” Comparable&amp;lt;T&amp;gt; 研究了一下, 于是本文将这两个接口的异同以及常见的一些使用场景总结了一下. Comp...
Comparable接口与Comparator接口的区别
m0_53193630的博客
10-31 542
compareTo 方法接收的参数 o 是要对比的对象，排序规则是用当前对象和要对比的对象进行比较，然后返回一个 int 类型的值。正序从小到大的排序规则是：使用当前的对象值减去要对比对象的值；而倒序从大到小的排序规则刚好相反：是用对比对象的值减去当前对象的值。2、Comparable是通过重写compare To方法来实现排序的，而Comparator是通过重写compare方法来实现排序的。3、Comparable必须自定义类内部实现排序方法，而Comparator是外部定义并实现排序的。
Comparable接口和Comparator接口的比较
12-20
Comparable接口和Comparator接口是Java中用于排序的关键组件，它们在数据结构如数组、集合和映射的排序过程中扮演着重要角色。接下来我们将深入探讨这两个接口的特性、用途以及它们之间的区别。 1. Comparable接口...
Comparable接口和Comparator使用示例
06-09
Comparable 接口和 Comparator 使用示例 在 Java 编程语言中，比较和排序是非常常见的操作。Comparable 接口和 Comparator 是两种常用的比较和排序方式。在本文中，我们将通过实例代码，详细介绍 Comparable 接口和...
Java编程：Comparable和Comparator接口
EVEcho的博客
01-15 614
博客内容：对docs的个人翻译、综合多个博客的总结表格、程序练习 Public Interface Comparable&lt;T&gt; T： the type of objects that this object may be compared to。要被比较的对象的类型 为实现Comparable接口的类的对象强加impose全排序。这里的排序指类的自然顺序natural order...
Comparable接口和Comparator接口（java笔记）
qq_42902163的博客
04-15 360
Comparable： 从字面理解，Comparable是可比较的意思。 从源码来看：Comparable接口只有一个方法： public int compareTo(T o); 具体需要实现的功能： 结合源码和字面意思来看：所有实现了Comparable接口的类都是一个可以进行比较的类，而且可以和任意类型的对象进行比较，但是比较的方法就具体由自己来定义实现。 所有的包装类好像都实现了这个接口。 ...
Comparable接口与Comparator接口的使用
qq_45331503的博客
02-08 303
这两个接口适用于排序 Comparable接口和Comparator接口的区别 Comparable接口位于java.lang包下；Comparator位于java.util包下 Comparable接口只提供了一个compareTo()方法；Comparator接口不仅提供了compara()方法，还提供了其他默认方法，如reversed()、thenComparing()，使我们可以按照更多的方式进行排序 如果要用Comparable接口，则必须实现这个接口，并重写comparaTo()方法
Comparable 接口和 Comparator 接口
03-01
### Java 中 `Comparable` 和 `Comparator` 接口的区别及用法 #### 定义与用途 `Comparable<T>` 是一个内置接口，用于定义对象的自然顺序。当类实现此接口时，意味着该类的对象可以按照某种逻辑进行比较。通常情况下，这种逻辑基于某个属性，比如字符串按字母顺序排列或数值类型的大小。 ```java public class Employee implements Comparable<Employee> { private String name; private int age; // Constructor, getters and setters omitted for brevity @Override public int compareTo(Employee other) { return Integer.compare(this.age, other.getAge()); } } ``` 相比之下，`Comparator<T>` 提供了一种灵活的方式来指定额外的排序标准而无需修改原始类的设计。这允许开发者在同一组数据上应用不同的排序策略[^3]。 ```java import java.util.Comparator; public class AgeSorter implements Comparator<Employee> { @Override public int compare(Employee o1, Employee o2) { return o1.getAge() - o2.getAge(); } } ``` #### 使用场景 - **`Comparable`**: 当希望给定类型的实例具有固定的、内在的排序方式时使用。例如，在集合框架中存储自定义对象并期望它们能够自动排序的情况下非常有用。 - **`Comparator`**: 如果需要根据不同条件动态改变排序行为，则更适合采用这种方式。它还可以用来处理那些无法控制其源码的情况下的外部类排序需求。 通过上述两种方法之一来定制化排序机制，可以使程序更加模块化且易于维护。值得注意的是，虽然两者都可以完成相似的任务，但在具体应用场景下各有优劣。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值