了解Java中的自定义比较器[duplicate]

Question

我创建了一个自定义比较器，可以按降序对获胜数进行排序，但我不确定它是如何工作的，有人能解释一下这是如何按降序排序的吗？

public static Comparator<FootballClub> sortNumOfWins = new Comparator<FootballClub>() {

    public int compare(FootballClub footballClub1, FootballClub footballClub2) {

        int numOfWins1 = footballClub1.getNumOfWins();
        int numOfWins2 = footballClub2.getNumOfWins();

        /*Returns the number of goals scored in  descending order*/
        return numOfWins2 - numOfWins1;
    }
};

Answer 1

返回值告诉调用方哪个项目“更大”（或者它们是否相等）

1 : numOfWins1 < numOfWins2
0 : numOfWins1 == numOfWins2
-1 : numOfWins1 > numOfWins2

(正1或负1也可以是其他整数，如-2/2，-100/100，任何正/负数)

所以，当你回来的时候:

return numOfWins2 - numOfWins1;

如果 OfWins2，它将是一个正数

如果numOfWins2，则为负数

和0如果numOfWins2==numOfWins1

Answer 2

尝试以下代码:

    public static Comparator<FootballClub> sortNumOfWins = new Comparator<FootballClub>() {

    public int compare(FootballClub footballClub1, FootballClub footballClub2) {

        Integer numOfWins1 = footballClub1.getNumOfWins();
        Integer numOfWins2 = footballClub2.getNumOfWins();

        return numOfWins2.compareTo(numOfWins1);
    }
};

当您仅比较整数字段并且此比较是典型的时，可以使用标准方法 compareTo 从整数类型。

Answer 3

Comparator#compare方法的目标是什么？

比较其两个参数的顺序。当第一个参数小于、等于或大于第二个参数时，返回负整数、零或正整数。

给定您的< code >(numofwins 2-numofwins 1)公式:

• 对于numOfWins1=30和numOf Wins2=20的情况，（20-30）是-10，一个负数。所以第一个应该排在第二个之后
• 对于numOfWins1=20和numOf Wins2=30的情况，（30-20）是10，一个正数。所以第一个应该排在第二个之上
• 对于numOfWins1=25和numOf Wins2=25的情况，（25-25）为0，零。因此，这两个项目是并列排序的

下面是一些示例代码。您可以调整Alice和Carol的构造函数，以查看排序操作。

这段代码使用了一个类的新的compact record定义。这是Java 16的一个特性。但是使用< code>record与本答案无关。您也可以使用传统的类定义。

package work.basil.example;

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

public class Comparing
{
    public static void main ( String[] args )
    {
        Comparing app = new Comparing();
        app.demo();
    }

    private void demo ( )
    {
        List < FootballClub > clubs =
                List.of(
                        new FootballClub( "Alice" , 25 ) ,
                        new FootballClub( "Bob" , 7 ),
                        new FootballClub( "Carol" , 25 )
                );

        Comparator < FootballClub > sortByWinsDescending = new Comparator < FootballClub >()
        {

            public int compare ( FootballClub footballClub1 , FootballClub footballClub2 )
            {

                int numOfWins1 = footballClub1.wins();
                int numOfWins2 = footballClub2.wins();

                /* Returns the number of goals scored in  descending order */
                return numOfWins2 - numOfWins1;
            }
        };

        List < FootballClub > sorted = new ArrayList <>( clubs );
        sorted.sort( sortByWinsDescending );

        System.out.println( "clubs = " + clubs );
        System.out.println( "sorted = " + sorted );
    }

    record FootballClub(String name , Integer wins)
    {
    }
}

这个代码返回（numOfWins2-numOfWins1）；是那种应该避免的“巧妙”编程。这段代码令人困惑和麻烦。我甚至在写这个答案的时候把自己弄糊涂了。

最好是让对象自己比较。在我的示例代码中，我们使用类Integer。嗯，Integer对象已经知道如何比较它们自己。因此，调用Integer#compareTo。

return footballClub1.wins().compareTo( footballClub2.wins() ) ;

或者，对于代码中所示的整数基元，调用静态实用工具方法 Integer.compare（ int x ， int y ）：

        int numOfWins1 = footballClub1.getNumOfWins();
        int numOfWins2 = footballClub2.getNumOfWins();

        /* Returns the number of goals scored in  descending order */
        return Integer.compare ( numOfWins1 , numOfWins2 ) ;

顺便说一句，我们可以查看OpenJDK源代码，看看这Integer是如何实现的。实现了compare（intx，inty）方法。它们使用一对嵌套的三元运算符。A<代码>：三元是这样工作的：如果谓词测试为true，则使用后面的项，否则为false，请使用：后面的项。

// Copyright (c) 1994, 2020, Oracle and/or its affiliates. All rights reserved.
// Excerpt from https://github.com/openjdk/jdk/blob/master/src/java.base/share/classes/java/lang/Integer.java
// See licensing terms in that original file.
return (x < y) ? -1 : ((x == y) ? 0 : 1);

养成编写代码的习惯——这是尽可能简单明了的。人类花在阅读代码上的时间比写代码要多得多。在一个作业中，当您的一个报告生成方法中有一个bug，并且您正在半夜进行调试时，您不想试图确定return numOfWins2-numOfWins1是升序还是降序。

作为奖励，人类可读的简单代码通常更有可能成为Java编译器和运行时优化性能的机会。

为了好玩，在return语句之前添加这一行，以查看各个比较。

System.out.println( "numOfWins1: " + numOfWins1 + " | numOfWins2: " + numOfWins2 + " | numOfWins2 - numOfWins1: " + ( numOfWins2 - numOfWins1 ) );

提示： 如果你想要升序而不是降序，只需将调用的结果相乘整数#compareTo 或整数比较，再乘以负 1 （-1）。这样做会翻转结果的符号，负变为正，正变为负，零保持为零。

return ( -1 * Integer.compare ( numOfWins1 , numOfWins2 ) ) ;  // Ascending rather than descending sort order.

正如Ole V.V.所评论的那样，如果您对lambdas和方法引用感到满意，那么可以通过调用Comparator.comparingInt将整个Comparatorimplementation分解为单行解决方案进行升序排序。

Comparator < FootballClub > sortByWinsDescending = Comparator.comparingInt( FootballClub :: wins );

我们上面的例子变得非常短。

package work.basil.example;


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

public class Comparing2
{
    public static void main ( String[] args )
    {
        Comparing2 app = new Comparing2();
        app.demo();
    }

    private void demo ( )
    {
        List < FootballClub > clubs =
                List.of(
                        new FootballClub( "Alice" , 20 ) ,
                        new FootballClub( "Bob" , 7 ) ,
                        new FootballClub( "Carol" , 30 )
                );

        Comparator < FootballClub > sortByWinsDescending = Comparator.comparingInt( FootballClub :: wins );

        List < FootballClub > sorted = new ArrayList <>( clubs );
        sorted.sort( sortByWinsDescending );

        System.out.println( "clubs = " + clubs );
        System.out.println( "sorted = " + sorted );
    }

    record FootballClub(String name , Integer wins)
    {
    }
}