Comparator比较器

原创 已于 2025-01-12 09:53:41 修改 · 1.8k 阅读 · 26 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

于 2025-01-12 09:45:13 首次发布

目录

1. 用处

2. 规范

3. 比较器功能方法

3.1. int compare(T o1,T o2)

3.2. boolean equals(Object obj)

4. 比较器的使用

4.1. Stream.sorted

4.2. Collections.sort

4.3. List.sort

5. 常见方法

5.1. reversed()

5.2. thenComparing()

5.3. <静态>reverseOrder()

5.4. <静态>naturalOrder()

5.5. <静态>nullsFirst()

5.6. <静态>nullsLast()

5.7. <静态>comparing()

1. 用处

用于对对象集合进行总排序：

  1. 传递给排序方法（如 Collections.sort / Arrays.sort），以便精确控制排序顺序。
  2. 用于控制某些数据结构的排序。
  3. 为没有 natural ordering 的对象集合提供排序。

2. 规范

  1. 实现此接口的对象列表可以通过Collections.sort 和 Arrays.sort 自动排序。无序指定比较器。
  2. 当且仅当类 C 的 e1 和 e2 的 e1.compareTo(e2) == 0 的布尔值与 e1.equals(e2) 的布尔值相同时，类 C 的自然排序被认为与等价一致。
  3. 强烈建议 a.equals(b)和 a.compareTo(b) == 0的逻辑相同，否则将会发生奇怪的错误。
  4. 如果将比较器作用于一个可序列化的数据结构，如 TreeSet和 TreeMap，则实现比较器接口时也需要实现 Serializable 接口进行序列化。

3. 比较器功能方法

3.1. int compare(T o1,T o2)

用来比较两个参数的大小：当 o1 小于、等于、大于 o2 时，分别返回负值、零、正值。

其实现方式有两种：使用 lambda 表达式定义、自定义 compare 实现比较器。

实现一：使用 lamdba 表达式

定义方式：

// 通过Student的age属性进行比较
Comparator<Student> ageComp =(s1 , s2) -> s1.getAge() - s2.getAge();
// 通过Student的name属性进行比较
Comparator<Student> nameComp = (s1 , s2) -> s1.getName() - s2.getName();

使用示例：

import java.util.Comparator;
import java.util.List;
public class CompareDemo {
  public static void main(String[] args) {
	List<Student> list = Student.getStudentList();
	
	System.out.println("--- Sort Students by age ---");
	
	Comparator<Student> ageComp = (s1, s2) -> s1.getAge() - s2.getAge();
	list.sort(ageComp);
	list.forEach(s -> System.out.println(s));
	
	System.out.println("--- Sort Students by name ---");
	
	Comparator<Student> nameComp = (s1, s2) -> s1.getName().compareTo(s2.getName());	
	list.sort(nameComp);
	list.forEach(s -> System.out.println(s));	
  }
}

实现二：自定义 compare 实现比较器

定义方式：

class AgeComparator implements Comparator<Strudent> , Serializable{
    private static final long serialVersionUID = 1L;
    @Override
    public int compare(Student s1, Student s2){
        return s1.getAge - s2.getAge;
    }
}

3.2. boolean equals(Object obj)

重写了 Object 的 equals 方法，用于比较两个比较器是否相等；

当 obj 也是一个比较器，并且他的排序于此比较器相同时，才会返回 true。也就是说，comp1.equals(comp2)意味着对于任意的 o1,o2 都有 sgn(comp1.compare(o1, o2))==sgn(comp2.compare(o1, o2)) ,其中的 sgn 是 java 中的符号函数，将正数返回 1，负数返回 -1,0 依然返回 0；

4. 比较器的使用

可以将比较器与 Stream.sorted/Collections.sort/List.sort/Arrays.sort方法相结合来使用。

4.1. Stream.sorted

Stream.sorted 返回一个由这个流的元素组成的流，根据提供的比较器进行排序。

import java.util.Comparator;
import java.util.List;
public class CompareDemoStreamSorted {
  public static void main(String[] args) {
	List<Student> list = Student.getStudentList();
	
	System.out.println("--- Sort Students by age ---");
	
	Comparator<Student> ageComp = (s1, s2) -> s1.getAge() - s2.getAge();
	list.stream().sorted(ageComp).forEach(s -> System.out.println(s));
	
	System.out.println("--- Sort Students by name ---");
	
	Comparator<Student> nameComp = (s1, s2) -> s1.getName().compareTo(s2.getName());	
	list.stream().sorted(nameComp).forEach(s -> System.out.println(s));	
  }
}

4.2. Collections.sort

Collections.sort 根据给定的比较器实例对指定的列表进行排序。

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class CompareDemoCollectionsSort {
  public static void main(String[] args) {
	List<Student> list = Student.getStudentList();
	
	System.out.println("--- Sort Students by age ---");
	
	Comparator<Student> ageComp = (s1, s2) -> s1.getAge() - s2.getAge();
	Collections.sort(list, ageComp);
	list.forEach(s -> System.out.println(s));
	
	System.out.println("--- Sort Students by name ---");
	
	Comparator<Student> nameComp = (s1, s2) -> s1.getName().compareTo(s2.getName());	
	Collections.sort(list, nameComp);
	list.forEach(s -> System.out.println(s));	
  }
}

4.3. List.sort

List.sort 根据给定的比较器实例对这个列表进行排序。

import java.util.Comparator;
import java.util.List;
public class CompareDemoListSort {
  public static void main(String[] args) {
	List<Student> list = Student.getStudentList();
	
	System.out.println("--- Sort Students by age ---");
	
	Comparator<Student> ageComp = (s1, s2) -> s1.getAge() - s2.getAge();
	list.sort(ageComp);
	list.forEach(s -> System.out.println(s));
	
	System.out.println("--- Sort Students by name ---");
	
	Comparator<Student> nameComp = (s1, s2) -> s1.getName().compareTo(s2.getName());	
	list.sort(nameComp);
	list.forEach(s -> System.out.println(s));	
  }
}

5. 常见方法

5.1. reversed()

  • 返回一个比较器，该比较器的排序与此比较器相反。

5.2. thenComparing()

当两个对象通过主排序规则比较结果相等时，thenComparing 方法会提供一个次级排序规则来进一步比较。这种链式调用可以实现多级排序（先按照第一个规则排序，如果相等再按照第二个规则排序）

thenComparing 的重载方法：

  1. thenComparing(Comparator<? super T> other)
    1. 接受另一个 Comparator 作为次级排序规则。
  1. thenComparing(Function<? super T, ? extends U> keyExtractor)
    1. 接受一个函数，从对象中提取键值，然后使用自然排序。
  1. thenComparing(Function<? super T, ? extends U> keyExtractor, Comparator<? super U> keyComparator)
    1. 接受一个函数和一个比较器，先提取键值，再使用指定的比较器进行排序。
  1. thenComparingInt(ToIntFunction<? super T> keyExtractor)
    1. 专门用于比较整数键值，效率更高。 ‘

代码示例：

// Person类
class Person {
    String name;
    int age;
    double height;

    public Person(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + ", height=" + height + '}';
    }
}

//示例
import java.util.*;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 30, 5.4),
            new Person("Bob", 25, 5.8),
            new Person("Charlie", 30, 5.4),
            new Person("David", 30, 5.9),
            new Person("Eve", 25, 5.8)
        );

        // 多级排序：先按年龄，再按身高，再按姓名
        Comparator<Person> comparator = Comparator
            .comparingInt((Person p) -> p.age) // 主排序：按年龄升序
            .thenComparingDouble(p -> p.height) // 次排序：按身高升序
            .thenComparing(p -> p.name); // 再次排序：按姓名字典序

        // 排序
        people.sort(comparator);

        // 输出结果
        people.forEach(System.out::println);
    }
}

重载方法 3 的代码示例：

    class Product {
        String name;
        double price;
        double rating;

        public Product(String name, double price, double rating) {
            this.name = name;
            this.price = price;
            this.rating = rating;
        }

        @Override
        public String toString() {
            return "Product{name='" + name + "', price=" + price + ", rating=" + rating + '}';
        }
    }

    @Test
    public void test(){
        List<Product> products = Arrays.asList(
                new Product("Laptop", 1200.0, 4.5),
                new Product("Phone", 800.0, 4.8),
                new Product("Tablet", 800.0, 4.4),
                new Product("Monitor", 300.0, 4.8),
                new Product("Keyboard", 300.0, 4.5),
                new Product("Mouse", 300.0, 4.5)
        );

        // 定义排序规则
        Comparator<Product> comparator = Comparator
                // 主排序规则：按价格升序
                .comparingDouble((Product p) -> p.price)
                // 次排序规则：按评分降序
                .thenComparing(
                        (Product p) -> p.rating,
                        (rating1, rating2) -> Double.compare(rating2, rating1)
                )
                // 再次排序规则：按名称字典序升序
                .thenComparing(p -> p.name);

        // 对商品列表排序
        products.sort(comparator);

        // 输出排序后的结果
        products.forEach(System.out::println);
    }

5.3. <静态>reverseOrder()

返回一个比较器，这个比较器的排序规则是自然排序的逆序。

5.4. <静态>naturalOrder()

返回一个比较器，这个比较器的排序规则是自然排序。

5.5. <静态>nullsFirst()

返回一个对空值友好的比较器，她会认为 null 小于非空值，即排序后 null 值处于列表的最前方。

5.6. <静态>nullsLast()

返回一个对空值友好的比较器，她会认为 null 大于非空值，即排序后 null 值处于列表的最后方。

5.7. <静态>comparing()

  1. comparing(Function<? super T,? extends U> keyExtractor)

接受一个函数，该函数从类型 T 中提取 Comparable 排序键，并返回一个按该排序键进行比较的 Comparator<T>.

eg:

Comparator<Student> nameComparator = Comparator.comparing(Student::getName); 
/**
这个排序器用于Student类，用于按照name的字典序排序。
*/

  1. comparing(Function<? super T,? extends U> keyExtractor, Comparator<? super U> keyComparator)

接受一个从类型 T 中提取排序键的函数，并返回一个使用指定 Comparator 按该排序键进行比较的 Comparator<T>.

  1. comparingDouble(ToDoubleFunction<? super T> keyExtractor)

作用同 1，不过要求提取出的排序键必须是 double 类型。

  1. comparingInt(ToIntFunction<? super T> keyExtractor)

作用同 1，不过要求提取出的排序键必须是 int 类型。

  1. comparingLong(ToLongFunction<? super T> keyExtractor)

作用同 1，不过要求提取出的排序键必须是 Long 类型。

亦赴尘
关注
【JavaEE基础与高级 第43章】LinkHashSet、Treeset的Comparable接口自然排序和Comparator比较器排序使用
KJ.JK
09-06 1万+
"LinkedHashSet" "继承了HashSet" ，底层在 "哈希表" 的基础上，又维护了一个 "双向链表" * LinkedHashSet 通过双向链表实现了元素的存取有序性(既可以去重 , 也可以保留原来的顺序) //底层是哈希表和双向链表。...
Comparator比较器接口使用原理
xmz1193184480的博客
02-07 3085
java.util.Comparator是比较器接口，如果我们需要控制某个类的次序并且该类本身不支持排序，那么就可以建立一个类比较器来进行排序，实现方式很简单只需要实现java.util.Comparator接口。 java.util.Comparator接口只包括两个函数，它的源码如下图： 1) 若一个类要实现java.util.Comparator接口：它一定要实现in
比较器（Comparable、Comparator）
08-06
NULL 博文链接：https://chaoyi.iteye.com/blog/2082723
比较器Comparator简单用法
09-29
简单的用commons的jar包，运用其中Comparator的方法，希望对你有所帮助。
自定义排序Comparator
最新发布
qq_33271461的博客
08-09 506
Comparator
【java】Comparator的用法
热门推荐
峰峯的专栏
02-15 21万+
为什么写？ 1. comparator 是javase中的接口，位于java.util包下，javase中的所有接口抽象度都很高，有必要重视 2. 网上太多的文章告诉大家comparator是用来排序；确实，可以用来排序，但不仅限于排序 3. 工作中实际需求出现很多需要使用comparator去处理的问题，在此总结一下。
学习Java第九天
weixin_42556780的博客
08-05 229
2020/8/2 1.集合ArrayList 1.集合的概述 集合就是一种容器，可以用来存储引用数据类型。 集合的长度可变，可以在容器中增删内容。 创建对象 创建集合对象 <>表示要存储的数据类型 ArrayList<String> 变量名 = new ArrayList<>(); 2.集合的常用方法 方法 说明 add(E e) 给集合添加元素 add(int index,E e) 给指定的索引处添加元素 remov
Java Comparator比较器实例解析
08-25
Java Comparator比较器实例解析 Java Comparator是一种强大的比较器接口，通过实现Comparator接口，可以自定义比较规则，实现对对象的排序和比较。本文将详细介绍Java Comparator比较器实例解析，通过示例代码介绍...
对比Java中的Comparable排序接口和Comparator比较器接口
09-02
Comparator是一个比较器接口，它提供了一种在类本身不支持排序的情况下控制对象次序的方式。通过实现Comparator接口，你可以创建一个独立于原始类的比较逻辑，这使得排序更灵活。Comparator接口包含两个方法：`...
深入浅出Comparator比较器工具类
标题和描述中提到的“比较器工具类(comparator比较器工具类c)”以及标签“comparator”都指向一个编程概念，即编程中用于比较两个对象是否相等或决定对象之间排序顺序的工具类。以下内容将详细探讨与comparator相关...
comparator比较器
smileYYR的博客
08-31 266
可以让集合中的元素按照某个规则进行排序 在源码中体现了,先判断是否有compare() 如果没有再判断是否有compareTo() Comparator<?super K> cpr = comparator; if(cpr != null){ do{parent = t; cmp = cpr.compare(key,t.key); if(cmp < 0) t = t.left; else if(cmp > 0) t = t.right; else return
比较器 Comparator
xiaozhu0301的博客
07-23 644
比起Comparable接口比较器Comparator为我们在排序中提供了更宽松和更加广泛的应用实例：在实际中，常常需要对一个商品按照不同属性来排序，这时我们就能通过写出自己的Comparator来实现不同的排序方式 [java] view plain copy [java] view plain copy publicclassGoods{ private...
比较器Comparator
喵酱
05-26 527
一、比较器Comparator 集合排序 Collections.sort(list,new MyCompare()); sort里面要传一个比较器。三种方式 1.1 新建一个类，实现接口Comparator import com.google.common.collect.Lists; import java.util.Collections; import java.util.Comparator; import java.util.List; public class Demo2 .
Comparator--比较器
小旭IT-分享技术
08-14 2438
Comparator--比较器前言一、Comparator概念二、使用方法总结 前言 今天在看系统自代堆的定义的时候发现了一个好东西，值得分享，那就是比较器 一、Comparator概念 定义： Comparator是外部比较器，用于比较来对象与对象之间的，两个对象进行比较，多用于集合排序，而Comparable可以认为是一个内比较器，根据对象某一属性进行排序的。 我的理解 需要将一个混乱的数组或者集合通过一定的规律输出时（升序或者降序）可以使用这个外部的比较器，他可以将一个定义的几..
利用Comparator比较器进行
o676448的博客
03-10 209
存储学生对象并遍历,创建TreeSet集合使用 带参构造方法 要求:按照年龄从小到大排序,年龄相同时，按照姓名的字母顺序排序 结论:用TreeSet集合存储自定义对象,带构造方法使用的是比较器排序对元素进行排序的 比较器排序,就是让集合构造方法接收Comparator的实现类对象,重写compare(To1,To2)方法 重写方法是,一定要注意排序规则必须按照主要条件和次要条件写
模拟比较器（Comparator）
qq_43359615的博客
05-01 1924
比较器结构如上图所示，基准电压VREF输入经过BUFFER模块后输出VREF和VREF/2，BUFFER输出可以配置为BYPASS，在配置成BYPASS使能后，BUFFER功能关闭，VREF直接输出，无法输出VREF/2。COMP1和COMP2分别为低功耗比较器和快速比较器，输入端连接方式如结构图所示，两个比较器产生输出信号输出至数字电路。⚫ 两个比较器，Comp1为低功耗比较器，Comp2为rail-to-rail快速比较器。⚫比较器负端输入为vref或者IO输入，比较器正端为IO输入。
comparator比较器原理
06-08
Comparator比较器是Java中的一个接口，它定义了一个用于比较两个对象的方法compare(Object obj1, Object obj2)。通过实现Comparator接口，我们可以自定义比较器来比较两个对象之间的大小关系。 在Java中，如果我们...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值