Как это компилируется?

Ответ 1

Он работает для меня без класса Extractor а также без вызова map(e → e) в потоковом конвейере. Фактически, потоковый список экстракторов вообще не нужен, если вы используете правильные общие типы.

Что касается того, почему ваш код не работает, я не совсем уверен. Дженерики - это жесткий и непроницаемый аспект Java... Все, что я делал, это настройка подписи метода parseKeysAscending, чтобы он соответствовал тому, что действительно ожидает Comparator.comparing.

Здесь метод parseKeysAscending:

public static <T, S extends Comparable<? super S>> Comparator<T> parseKeysAscending(
        List<Function<? super T, ? extends S>> keyExtractors) {

    if (keyExtractors.isEmpty()) {
        return (a, b) -> 0;
    } else {

        Function<? super T, ? extends S> firstSortKey = keyExtractors.get(0);
        List<Function<? super T, ? extends S>> restOfSortKeys = 
            keyExtractors.subList(1, keyExtractors.size());

        return Comparator.<T, S>comparing(firstSortKey)
            .thenComparing(parseKeysAscending(restOfSortKeys));
    }
}

И вот демо с вызовом:

List<Function<? super Data, ? extends Comparable>> extractors = new ArrayList<>();
extractors.add(Data::getA);
extractors.add(Data::getB);

Comparator<Data> test = parseKeysAscending(extractors);

List<Data> data = new ArrayList<>(Arrays.asList(
    new Data(1, "z"),
    new Data(2, "b"),
    new Data(1, "a")));

System.out.println(data); // [[1, 'z'], [2, 'b'], [1, 'a']]

data.sort(test);

System.out.println(data); // [[1, 'a'], [1, 'z'], [2, 'b']]

Единственный способ сделать компиляцию кода без предупреждений - объявить список функций как List<Function<Data, Integer>>. Но это работает только с геттерами, которые возвращают Integer. Я предполагаю, что вам может понадобиться сравнить любое сочетание Comparable s, то есть приведенный выше код работает со следующим классом Data:

public class Data {
    private final Integer a;
    private final String b;

    private Data(int a, String b) {
        this.a = a;
        this.b = b;
    }

    public Integer getA() {
        return a;
    }

    public String getB() {
        return b;
    }

    @Override
    public String toString() {
        return "[" + a + ", '" + b + "']";
    }
}

Вот демо.

EDIT: Обратите внимание, что с Java 8 последняя строка метода parseKeysAscending может быть:

return Comparator.comparing(firstSortKey)
        .thenComparing(parseKeysAscending(restOfSortKeys));

Хотя для более новых версий Java вы должны предоставить явные общие типы:

return Comparator.<T, S>comparing(firstSortKey)
        .thenComparing(parseKeysAscending(restOfSortKeys));

Ответ 2

После того, как Федерико исправил меня (спасибо!), Это единственный способ, которым вы могли бы это сделать:

public static <T, S extends Comparable<? super S>> Comparator<T> test(List<Function<T, S>> list) {
    return list.stream()
            .reduce((x, y) -> 0,
                    Comparator::thenComparing,
                    Comparator::thenComparing);
}

И использование будет:

// I still don't know how to avoid this raw type here
List<Function<Data, Comparable>> extractors = new ArrayList<>();
extractors.add(Data::getA); // getA returns an Integer
extractors.add(Data::getB); // getB returns a String

listOfSomeDatas.sort(test(extractors));

Ответ 3

1. Если я не определяю класс Extractor, это не будет компилироваться. Я не могу напрямую использовать Function или какой-то функциональный интерфейс.

Нет вы можете. Вы можете определить любую Function<X, Y> с помощью лямбда или ссылки на метод или анонимного класса.

List<Function<Data, Integer>> extractors = List.of(Data::getA, Data::getB);

2. Если я .map(e → e) строку отображения функции идентификации .map(e → e), это не будет вводить проверку.

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

extractors.<Function<Data, Integer>>stream().collect(Collectors.toList())

Но здесь нет необходимости:

Comparator<Data> test = parseKeysAscending(extractors);

3. Моя IDE заявляет, что моя функция принимает List Function типа Data,? который не соответствует границам функции parseKeysAscending.

Да, должно. Вы передаете List<Extractor<Data,?>> и компилятор не может понять ? часть. Это может быть или не быть Comparable то время как для вашего метода явно требуется S extends Comparable<S>.

Ответ 4

Что касается исходного кода в вопросе: вы можете удалить Extractor и использовать raw Comparable:

List<Function<Data, Comparable>> extractors = new ArrayList<>();

extractors.add(Data::getA);
extractors.add(Data::getB);

@SuppressWarnings("unchecked")
Comparator<Data> test = parseKeysAscending(extractors);

PS Но я не вижу, как избавиться от необработанного типа здесь...