Comparator<T> 外部比较器使用介绍

最新推荐文章于 2022-01-27 02:04:55 发布

谢苏、

最新推荐文章于 2022-01-27 02:04:55 发布

阅读量664

点赞数

CC 4.0 BY-SA版权

分类专栏： java 比较器工具类文章标签：比较器 Comparator Java8 jdk8

本文链接：https://blog.youkuaiyun.com/weixin_42327945/article/details/95939201

java 同时被 3 个专栏收录

28 篇文章

订阅专栏

比较器

2 篇文章

订阅专栏

工具类

2 篇文章

订阅专栏

本文介绍了如何在Java8中使用Comparator创建外部比较器。通过定义匿名内部类和使用lambda表达式，实现对对象属性的升序排序。在JDk 1.8中，Comparator接口提供了更简洁的实现方式，允许直接使用方法引用或函数式接口来完成比较操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

定义测试model类：

public class User {
    private Integer age;

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

    public Integer getAge() {
        return age;
    }

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

测试类：

此处使用最简单的匿名内部类实现重写比较函数，虚拟参数为o1，o2，返回值为 o1-o2（也可以返回 JDk默认的比较参数 -1,0,1用来比较大小），这样就实现了升序排序。


import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Comparator_test {

    public static void main(String[] args) {
        List<User> integerList = new ArrayList<User>() {{
            add(new User(1));
            add(new User(5));
            add(new User(3));

        }};

        Collections.sort(integerList, new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        Collections.reverse(integerList);

        integerList.forEach(System.out::println);

    }
}

//使用lambda表达式代替匿名内部类，查看Compatator 知道，在JDk 1.8 中此接口添加了

@FunctionalInterface，成为了一个函数式接口，而lamda可以用表达式或函数体表示，因此这里可以使用lambda简化代码。

(o1, o2) -> o1.getAge()-o2.getAge() ，此处，定义了两个参数，功能是返回两者的差值，作用与匿名内部类相同。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Comparator_test {

    public static void main(String[] args) {
        List<User> integerList = new ArrayList<User>() {{
            add(new User(1));
            add(new User(5));
            add(new User(3));

        }};

        Collections.sort(integerList, (o1, o2) -> o1.getAge()-o2.getAge());
        Collections.reverse(integerList);

        integerList.forEach(System.out::println);

    }
}

//使用函数代替lambda

查看

Comparator<T>源码可知，新添加了返回比较器的方法，Comparator.comparingInt(User::getAge)

源码如下：

    /**
     * Accepts a function that extracts an {@code int} sort key from a type
     * {@code T}, and returns a {@code Comparator<T>} that compares by that
     * sort key.
     *
     * <p>The returned comparator is serializable if the specified function
     * is also serializable.
     *
     * @param  <T> the type of element to be compared
     * @param  keyExtractor the function used to extract the integer sort key
     * @return a comparator that compares by an extracted key
     * @see #comparing(Function)
     * @throws NullPointerException if the argument is null
     * @since 1.8
     */
    public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
    }

参数还是函数式接口，方法体返回的功能即上个方法中lambda表达式的功能，因此这里可以再次化简我们的代码：


import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Comparator_test {

    public static void main(String[] args) {
        List<User> integerList = new ArrayList<User>() {{
            add(new User(1));
            add(new User(5));
            add(new User(3));

        }};

        Collections.sort(integerList, Comparator.comparingInt(User::getAge));
        Collections.reverse(integerList);

        integerList.forEach(System.out::println);

    }
}