Можно ли передавать ссылки BiFunction методам, ожидающим функциональный интерфейс?

Я не вижу в связанном ответе SO ничего, что противоречило бы статье.

Обычные правила системы типов применяются к функциональному интерфейсу.

Если вы объявите переменную как BiFunction<String,String,Integer> bifunc, вы не сможете передать ее методу, для которого требуется Comparator<String>, поскольку BiFunction<String,String,Integer> не является подтипом Comparator<String>.

Тот факт, что функциональные типы следуют всем обычным правилам, позволил добавить эту новую функциональность с минимальными изменениями.

И если вы хотите сделать Comparator из BiFunction, все, что вам нужно сделать, это добавить ::apply следующим образом:

BiFunction<String,String,Integer> bifunc = (a,b) -> 
                               Integer.compare(a.length(), b.length());

Arrays.sort(array, bifunc::apply);  

Статья правильная в том смысле, что нельзя сортировать по объекту типа BiFunction, но всегда можно, используя Comparator. Но эй, они оба могут иметь одно и то же тело. Например:

private static void sort(Comparator<String> ls){
        Arrays.sort(someArray, ls);
}

Comparator<String> comp = (String f1, String f2) -> Integer.compare(f1.length(), f2.length());
sort(comp);

BiFunction<String, String, Integer> func = (String f1, String f2) -> Integer.compare(f1.length(), f2.length());
sort((String f1, String f2) -> Integer.compare(f1.length(), f2.length())); //line-4

sort(func) // compiler error

Выше, в строке 4, вы можете передать лямбду, точно такую ​​же, как func. Но вы по-прежнему не можете передать func в sort. Лямбды в java8 являются реализацией некоторого FunctionalInterface. Функциональные интерфейсы получают свой тип на основе ссылочного типа. Вот как одна и та же лямбда при инициализации может быть либо BiFunction, либо Comparator.

Но как только лямбда построена и получает тип, вы не можете ее изменить. Следовательно, вы не можете передать func типа BiFunction для сортировки, которая ожидает Comparator

Статья правильная. Вы не можете назначить, например. от BiFunction до Comparator.

При этом эта замечательная статья написана Брайаном Гетцем. хорошо объясняет проблему.

Когда компилятор встречает лямбда-выражение, он сначала понижает (удаляет сахара) тело лямбда-выражения до метода, список аргументов и тип возвращаемого значения которого соответствуют таковым для лямбда-выражения.

Итак, лямбда может быть обессахарена, но что это значит? Ну, в основном это означает, что (может быть) создан новый метод, который каким-то образом соответствует лямбде.

class A {
    public void foo() {
        List<String> list = ...
        list.forEach( s -> { System.out.println(s); } );
    }
}

Приведенный выше код будет обессахарен примерно так:

class A {
    public void foo() {
        List<String> list = ...
        list.forEach( [lambda for lambda$1 as Consumer] );
    }

    static void lambda$1(String s) {
        System.out.println(s);
    }
}

Итак, в случае BiFunction и Comparator. Предоставленная лямбда может быть назначена обоим:

// Assign the lambda to a BiFunction
BiFunction<String, String, Integer> b1 =
        (first, second) -> Integer.compare(first.length(), second.length());

// Assign the lambda to a Comparator
Comparator<String> c1 =
        (first, second) -> Integer.compare(first.length(), second.length());

// But, once the lambda has been assigned to a type you can not reassign it
BiFunction<String, String, Integer> b2 = c1; // <-- Error

Обратите внимание, что после того, как лямбда была назначена типу (BiFunction или Comparator), ее нельзя переназначить, даже если лямбда-выражение совпадает.