我阅读了有关 Lambda 表达式的 Java 8 教程，但不太理解“对特定类型的任意对象的实例方法的引用”的方法引用示例

在同一教程中有一个示例“对特定对象的实例方法的引用”，看起来很像。

public int compareByName(Person a, Person b) {
        return a.getName().compareTo(b.getName());
}
Arrays.sort(rosterAsArray, myComparisonProvider::compareByName);

我可以看到这是有效的，因为方法 compareByName 具有与 Comparator.compare 相同的签名，lambda (a, b) -> myComparisonProvider.compareByName(a, b) 接受两个参数并调用具有相同两个参数的方法。

现在“对特定类型的任意对象的实例方法的引用”示例使用 String::compareToIgnoreCase

String[] stringArray = { "Barbara", "James", "Mary", "John",
    "Patricia", "Robert", "Michael", "Linda" };
Arrays.sort(stringArray, String::compareToIgnoreCase);

该方法的签名是 int compareTo(String anotherString) 并且不同于 Comparator.compare。该教程不是很清楚，但似乎暗示您最终会得到一个 lambda，例如 (a, b) -> a.compareToIgnoreCase(b) 我不明白编译器如何决定 Arrays.sort 的第二个参数可接受的参数我我想也许它足够聪明，可以理解如何调用该方法，所以我创建了一个示例。

public class LambdaTest {

    public static void main(String... args) {
        String[] stringArray = { "Barbara", "James", "Mary", "John", "Patricia", "Robert", "Michael", "Linda" };

        Arrays.sort(stringArray, String::compareToIgnoreCase);      // This works

        // using Static methods
        Arrays.sort(stringArray, FakeString::compare);              // This compiles
        Arrays.sort(stringArray, FakeString::compareToIgnoreCase);  // This does not

        // using Instance methods
        LambdaTest lt = new LambdaTest();
        FakeString2 fs2 = lt.new FakeString2();
        Arrays.sort(stringArray, fs2::compare);                 // This compiles
        Arrays.sort(stringArray, fs2::compareToIgnoreCase);     // This does not

        for(String name : stringArray){
            System.out.println(name);
        }
    }

    static class FakeString {
         public static int compareToIgnoreCase(String a) {
             return 0;
         }


        public static int compare(String a, String b) {
            return String.CASE_INSENSITIVE_ORDER.compare(a, b);
        }
    }

    class FakeString2 implements Comparator<String> {
         public int compareToIgnoreCase(String a) {
             return 0;
         }

        @Override
        public int compare(String a, String b) {
            return String.CASE_INSENSITIVE_ORDER.compare(a, b);
        }
   }
}

有人可以解释为什么上面两个 Arrays.sort 即使使用与 String.compareToIgnoreCase 方法相同的方法也不能编译

最佳答案

这是某个对象的方法引用与正在处理的对象的方法引用之间的区别。

首先是 Oracle 示例

让我们来看第一个案例:

public int compareByName(Person a, Person b) {
        return a.getName().compareTo(b.getName());
}
Arrays.sort(rosterAsArray, myComparisonProvider::compareByName);

在这里，方法compareByName在 myComparisonProvider 的传入实例上调用sort 中的每对参数算法。

所以在这里，比较a时和 b我们实际上调用:

final int c = myComparisonProvider.compareByName(a,b);

现在，在第二种情况下:

String[] stringArray = { "Barbara", "James", "Mary", "John",
    "Patricia", "Robert", "Michael", "Linda" };
Arrays.sort(stringArray, String::compareToIgnoreCase);

您正在排序 String[]所以方法 compareToIgnoreCase在 String 上调用当前正在与另一个实例一起排序 String作为论点。

所以在这里，比较a时和 b我们实际上调用:

final int c = a.compareToIgnoreCase(b);

所以这是两种不同的情况:

• 一个你在任意对象实例上传递一个方法；和
• 在其中传递要在正在处理的实例上调用的方法。

你的例子

现在在您的第一个示例中，您还有一个 String[]然后你尝试对它进行排序。所以:

Arrays.sort(stringArray, FakeString::compare);

所以在这里，比较a时和 b我们实际上调用:

final int c = FakeString.compare(a, b);

唯一的区别是 compare是static .

Arrays.sort(stringArray, FakeString::compareToIgnoreCase);

现在，String[]不是 FakeString[]所以我们不能在 String 上调用这个方法.因此我们必须调用 static FakeString 上的方法.但是我们也不能这样做，因为我们需要一个方法 (String, String) -> int但我们只有(String) -> int - 编译错误。

在第二个例子中问题是完全一样的，因为你仍然有一个 String[] .和 compareToIgnoreCase有错误的签名。

长话短说:

您缺少的一点是在 String::compareToIgnoreCase 中例子;该方法在 String 上调用正在处理中。

关于Java 8 和方法引用 - 特别是 compareToIgnoreCase，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29735146/