介绍

有时在做项目时需要对某种类型的对象集合进行排序，为此你可能会认为有必要实现我们自己的排序算法，但这有点不必要，尽管了解一下也没什么坏处他们如何工作。例如，如果您有一个整数数组，则可以使用 arrays.sort() 方法，该方法接受基元数组并按升序对其进行排序，从而利用无需将结果分配给新变量，因为该方法修改了原始数组。

int[] numbers = {9, 8, 5, 3, 1, 2, 4, 6, 7};
arrays.sort(numbers);
system.out.println(arrays.tostring(numbers));

// output
[1, 2, 3, 4, 5, 6, 7, 8, 9]

当您有自定义对象的集合（例如 movie 类型的记录）时，这也适用，但如果我们看到 arrays.sort() 方法，它不接受这种类型的对象数组，因此它必须是否可以使用接受 t 类型的对象和 comparator 这是一个函数式接口。这个接口非常重要，因为 java 中的许多其他方法都使用它以自定义方式比较对象。例如，list 对象的 collections.sort() 方法或 sort() 方法，甚至 streams 也接受 comparator 来对元素进行排序。

什么是比较器？

函数式接口comparator（函数式它可以写成lambda表达式）是一个允许你比较两个t类型对象的接口，因此它用于比较整数、字符串、自定义物体等该接口有几个静态和默认方法，但重要的是compare() 方法，它是比较两个对象必须实现的方法。 compare() 接收两个 t 类型的对象并返回一个整数。方法签名如下：

int compare(t o1, t o2);

如果o1小于o2，该方法返回负数；如果相等，则返回零；如果o1大于o2，该方法返回正数，通常分别返回-1、0或1。

一个对象小于、等于或大于另一个对象意味着什么？

让我们分析一下compare()方法返回的内容，因为对象的排序取决于此，重要的是要考虑该方法返回的含义是相对的，也就是说，如果您想要升序或降序排列。这取决于具体情况以及如何实施。让我们为每个示例考虑以下记录：

public record movie(
        string name,
        list<string> actors,
        int budget,
        int year
) {
}

• 如果第一个参数小于第二个参数，则返回负数。例如，要按发行年份对电影进行排序，当电影 a 小于电影 b 时，可以返回 -1：

// a < b -> -1
a.year() < b.year() -> -1

• 如果第一个参数大于第二个参数，则返回正数。例如，要按预算对电影进行排序，当电影 a 大于电影 b 时，可以返回 1：

// a > b -> 1
a.budget() > b.budget() -> 1

• 如果第一个参数等于第二个参数，则返回零。例如，要按演员数量对电影进行排序，当电影 a 等于电影 b 时，可以返回 0：

// a == b -> 0
a.actors().size() == b.actors().size() -> 0

使用比较器

假设我们在 list 类型的对象中有以下电影：

movie movie1 = new movie("the godfather", arrays.aslist("marlon brando", "al pacino"), 6000000, 1972);
movie movie2 = new movie("the godfather: part ii", arrays.aslist("al pacino", "robert de niro"), 13000000, 1974);
movie movie3 = new movie("the shawshank redemption", arrays.aslist("tim robbins", "morgan freeman"), 25000000, 1994);
movie movie4 = new movie("the dark knight", arrays.aslist("christian bale", "heath ledger"), 185000000, 2008);

list<movie> movies = arrays.aslist(movie1, movie2, movie3, movie4);

如果你想按上映年份升序对电影进行排序，你可以创建一个comparator类型的对象并重写compare()方法，然后将此对象传递给列表的sort()方法：

comparator<movie> comparatorbyyear = new comparator<movie>() {
    @override
    public int compare(movie o1, movie o2) {
        return o1.year() - o2.year();
    }
};

movies.sort(comparatorbyyear);

它也可以在 sort() 方法中实现为匿名类：

movies.sort(new comparator<movie>() {
    @override
    public int compare(movie o1, movie o2) {
        return o1.year() - o2.year();
    }
});

或者更简洁地直接在 sort() 方法中使用 lambda 表达式：

movies.sort((p1, p2) -> p1.year() - p2.year());

任何这些实现​​都会按发布年份对列表进行升序排序。如果要按降序排序，可以更改 lambda 表达式中参数的顺序，或者在减法中添加负号：

movies.sort((p1, p2) -> p2.year() - p1.year());
// o
movies.sort((p1, p2) -> - (p1.year() - p2.year()));

如何对自定义对象列表进行排序的一些其他示例是：

• 按演员数量升序排列电影（从少到多）：

movies.sort((p1, p2) -> p1.actors().size() - p2.actors().size());

• 按预算降序对电影进行排序（从最高预算到最低预算）：

movies.sort((p1, p2) -> p2.budget() - p1.budget());
// o 
movies.sort((p1, p2) -> - (p1.budget() - p2.budget()));

• 按名称升序对电影进行排序：

movies.sort((p1, p2) -> p1.name().compareto(p2.name()));

在其他示例中，我们可能会遇到需要按降序对整数列表进行排序的情况，

list<integer> numbers = arrays.aslist(5, 3, 1, 2, 4);
numbers.sort((n1, n2) -> n2 - n1);

// output
[5, 4, 3, 2, 1]

为此，您还可以使用静态方法 comparator.reverseorder() 返回一个按降序对元素进行排序的比较器，以及使用 comparator.naturalorder() 按升序对元素进行排序。

numbers.sort(comparator.reverseorder());
numbers.sort(comparator.naturalorder());

使用 integer.compare()

在 java 中已经有一些方法允许我们以有效的方式执行这种类型的比较，例如 integer.compare() ，它比较两个整数，如果第一个参数小于第二个参数零，则返回负数如果第一个参数大于第二个参数，则相等且为正数。如果我们分析这个方法的工作原理，我们可以看到它与上面解释的类似，并且返回的正是comparator接口的compare()方法所需要的。 integer.compare() 的实现如下：

public static int compare(int x, int y) {
    return (x < y) ? -1 : ((x == y) ? 0 : 1);
}

因此，如果您想按发行年份升序对电影进行排序，可以使用 integer.compare():

movies.sort((p1, p2) -> integer.compare(p1.year(), p2.year()));

使用参考方法

有时可以使用引用方法来执行与以前不同的比较，例如，按升序对整数列表进行排序：

list<integer> numbers = arrays.aslist(5, 3, 1, 2, 4);
numbers.sort(integer::compareto);

// output
[1, 2, 3, 4, 5]

integer 不是唯一具有compareto() 方法的类，例如 string 有一个compareto() 方法，可以按字典顺序比较两个字符串，因此它可以用于对字符串列表进行排序，甚至可以将 charsequence 与其一起使用compare() 方法（技术上表示字符序列）。

list<string> names = arrays.aslist("john", "alice", "bob", "charlie");
names.sort(charsequence::compare);
names.sort(string::compareto);

// output
[alice, bob, charlie, john]

回到电影的例子，如果你想按照上映年份升序对电影进行排序，可以使用compareingint()方法作为参考方法：

movies.sort(comparator.comparingint(movie::year));

或者根据 string 类型属性进行比较，在本例中为电影名称：

movies.sort(comparator.comparing(movie::name));

按多个属性排序

有时你可能需要按多个属性对对象列表进行排序，例如，如果你想按发行年份升序对电影进行排序，按预算降序排序，你可以使用 thencomparing() 方法，该方法接收一个比较器，负责按多个属性排序。例如，如果有两部电影a和b，上映年份相同，则按预算排序。

movies.sort(Comparator.comparingInt(Movie::year).thenComparing((p1, p2) -> p2.budget() - p1.budget()));

结论

比较器在java中很多时候都很有用，因为它们可以让你以个性化的方式比较对象，不仅如此，它们还可以用在许多java集合方法中，甚至可以有多个比较器来排序以不同的方式。无论哪种方式，您都可以查阅 ide 中的 comparator 文档或官方 java 文档，了解可以使用哪些方法以及如何实现它们。

立即学习“Java免费学习笔记（深入）”；

以上就是Java 中的比较器是如何工作的？的详细内容，更多请关注php中文网其它相关文章！