generics - 通过函数列表构建链式比较器

Question

我正在考虑用更现代的代码替换一些旧的比较器代码。

public int compare(String o1, String o2) {
    if (null == o1 && null == o2)
        return 0;
    if (null == o1)
        return -1;
    if (null == o2)
        return 1;
    if (0 == o1.length() && 0 == o2.length())
        return 0;
    if (0 == o1.length())
        return -1;
    if (0 == o2.length())
        return 1;
    int result = Integer.compare(o1.length(), o2.length());
    if (0 != result)
        return result;
    result = Character.compare(o1.charAt(0), o2.charAt(0));
    if (0 != result)
        return result;
    return o1.compareTo(o2);
}

我了解 Java 8 的 Comparator 方法，所以上面可以变成:

Comparator<String> chained = Comparator.nullsFirst(
    Comparator.comparingInt(String::length)).thenComparing(
        s -> s.length() == 0 ? -1 : s.charAt(0)).thenComparing(
        Function.identity());

但是，有点烦人，我需要写出 comparing和thenComparing对于每个比较。理想情况下，我只需传入一个列表或多个 lambda。

类似于:

Comparator.comparing(
    String::length, 
    s -> s.length() == 0 ? 0 : s.charAt(0), 
    Function.identity());

以下是我得到的最接近的内容，其中一些注释部分表明由于泛型不匹配而无效的内容。症结似乎是我想传递多个 Function<T, ?>通配符未固定到单个捕获。我猜这是不可能的。

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.function.Function;

public class MultiComparator<T> implements Comparator<T> {
    private Comparator<T> comparator;

    public MultiComparator() {
        this.comparator = Comparator.nullsFirst(Comparator.comparing(o -> 0));
    }

    /*
    public MultiComparator(List<Function<T, ? extends Comparable<?>>> extractors) {
        this();
        extractors.stream().forEach(this::add);
    }

    public MultiComparator(Function<T, ? extends Comparable<?>>... extractors) {
        this(Arrays.asList(extractors));
    }
    */

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("1", "11", "111", "2", "22", "222", "3", "123", "432", "aaa", "1234",
                "", "", null, null, null);

        MultiComparator<String> multi = new MultiComparator<>();

        multi.add(String::length);
        multi.add(s -> s.length() == 0 ? 0 : s.charAt(0));
        multi.add(Function.identity());

        Collections.shuffle(strings);
        Collections.sort(strings, multi);
        System.err.println(strings);

        /*
        multi = new MultiComparator<>(String::length, s -> s.length() == 0 ? -1 : s.charAt(0));

        Collections.shuffle(strings);
        Collections.sort(strings, multi);
        System.err.println(strings);
        */

        Comparator<String> chained = Comparator.nullsFirst(Comparator.comparingInt(String::length)).thenComparing(s
                -> s.length() == 0 ? -1 : s.charAt(0)).thenComparing(Function.identity());

        Collections.shuffle(strings);
        Collections.sort(strings, chained);
        System.err.println(strings);

        Collections.shuffle(strings);
        Collections.sort(strings, (o1, o2) -> {
            if (null == o1 && null == o2) return 0;
            if (null == o1) return -1;
            if (null == o2) return 1;
            if (0 == o1.length() && 0 == o2.length()) return 0;
            if (0 == o1.length()) return -1;
            if (0 == o2.length()) return 1;
            int result = Integer.compare(o1.length(), o2.length());
            if (0 != result) return result;
            result = Character.compare(o1.charAt(0), o2.charAt(0));
            if (0 != result) return result;
            return o1.compareTo(o2);
        });
        System.err.println(strings);
    }

    public <U extends Comparable<U>> void add(Function<T, U> fieldExtractor) {
        this.comparator = this.comparator.thenComparing(Comparator.nullsFirst(Comparator.comparing(fieldExtractor)));
    }

    @Override
    public int compare(T o1, T o2) {
        return this.comparator.compare(o1, o2);
    }
}

从好的方面来说，我可以只使用 thenComparing，而不必编写自己的实用程序类。

<小时/> <小时/>

感谢 Tagir Valeev 的解决方案，最终我放弃了自定义 Comparator 类，只有两个方法来返回新的 Comparator。

@SuppressWarnings("unchecked")
public static <T> Comparator<T> create(List<Function<T, ? extends Comparable<?>>> extractors) {
    return extractors.stream().map(e -> Comparator.comparing((Function<T, Comparable<Object>>) e)).reduce
            (Comparator::thenComparing).orElse(Comparator.comparing(o -> 0));
}

@SafeVarargs
public static <T> Comparator<T> create(Function<T, ? extends Comparable<?>>... extractors) {
    return create(Arrays.asList(extractors));
}

Answer 1

这是可以解决的，但未经检查的强制转换是必要的。首先声明add通过以下方式:

public <U extends Comparable<? super U>> void add(Function<T, U> fieldExtractor) {
    this.comparator = this.comparator.thenComparing(
                           Comparator.nullsFirst(Comparator.comparing(fieldExtractor)));
}

我替换了U extends Comparable<U>与 U extends Comparable<? super U> 。这是完全正常的。现在构造函数:

@SuppressWarnings("unchecked")
public MultiComparator(List<Function<T, ? extends Comparable<?>>> extractors) {
    this();
    extractors.stream().forEach(e -> this.add((Function<T, Comparable<Object>>)e));
}

@SafeVarargs
public MultiComparator(Function<T, ? extends Comparable<?>>... extractors) {
    this(Arrays.asList(extractors));
}

现在您的代码可以工作，甚至不会产生警告:

multi = new MultiComparator<>(String::length, s -> s.length() == 0 ? -1 : s.charAt(0));