Java8和方法参考-具体比较ToIgnoreCase

Question

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

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

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

我可以看到这个工作，因为方法compareByName与Comparator.comparelambda（a， b）具有相同的签名-

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

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

该方法的签名是int compareTo（String anotherString），与Comparator不同。比较本教程不太清楚，但似乎暗示您最终会得到一个lambda，如（a，b）-

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);
        }
   }
}

有人能解释一下为什么上面两个数组。sort不编译，即使它们使用的方法与String相同。比较IgnoreCase方法

Answer 1

在FakeString中，您的compareToIgnoreCase有一个字符串参数，因此它不能代替比较器

在FakeString 2中，您的compareToIgnoreCase有一个隐式FakeString参数（this）和一个字符串参数，因此它同样不能代替Comparator

Answer 2

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

首先是Oracle示例

让我们看看第一种情况：

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

这里，对传入的myComparisonProvider实例调用方法compareByName，并使用排序算法中的每对参数。

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

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

现在，在第二种情况下：

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

您正在排序一个字符串[]，因此将对当前正在排序的字符串实例调用方法compareToIgnoreCase，并将另一个字符串作为参数进行排序。

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

final int c = a.compareToIgnoreCase(b);

这是两种不同的情况：

• 一种在任意对象实例上传入方法的方法；和

在您的示例中

现在，在第一个示例中，您还有一个字符串[]，并尝试对其进行排序。因此：

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

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

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

唯一的区别是比较是静态的。

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

现在，String[]不是FakeString[]，因此我们不能在String上调用此方法。因此，我们必须在FakeString上调用静态方法。但我们也不能这样做，因为我们需要一个方法（String， String）-

在第二个示例中，问题完全相同，因为您仍然有一个String[]。和compareToIgnoreCase有错误的签名。

您缺少的一点是，在示例中；对当前正在处理的字符串调用该方法。