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

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 而无需编写自己的实用程序 class。

感谢 Tagir Valeev 的解决方案，最后我放弃了自定义比较器 class，只有两种方法可以 return 一个新的比较器。

@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

这个是可以解决的，但是unchecked cast是必须的。首先按以下方式声明 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<? super U> 替换了 U extends Comparable<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));

Answer 2

我不认为保存几个字母 thenComparing 值得编写任何额外的代码。你甚至会失去通用解决方案的性能，因为你不能使用 comparingInt 等，因此不得不忍受不必要的装箱开销。

与其编写实用程序方法，不如花时间思考实际比较的内容：

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

首先，您按长度比较字符串，只有当它们的长度不同时，您的比较器才会求助于其他比较器。第二个将比较第一个字符，这是一个过时的操作，因为第三个比较器将逐个字符比较字符串 从第一个 .

开始

由于对空字符串的特殊处理，它可能看起来很特别，但让我们看看可能的情况：

两个字符串都是空的；在这种情况下，后续比较器已过时，因为它们都将具有相同的结果，两个空字符串始终相等。第三个比较器就足够了
只有一个字符串为空；在这种情况下，第二个和第三个比较器都不会被调用，因为不同长度的字符串已经被第一个基于长度的比较器认为是不相等的
两者都不为空；在这种情况下，如前所述，第二个比较器已过时，因为第三个比较器无论如何都会比较第一个字符

所以你看，在所有情况下，第二个比较器都是过时的——所以让我们看看第三个：.thenComparing(Function.identity()); 是一种伪装，因为 identity() 不是真正的属性。它使链看起来好像有三个属性要比较，但实际上，它委托给普通字符串比较，也就是 String class 的 自然顺序 。

对于自然顺序，我们不需要创建比较器，我们可以使用existing one.

所以得到的比较器是：

Comparator<String> chained = Comparator.nullsFirst(
    Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()));

或者，使用 import static java.util.Comparator.*;:

Comparator<String> chained = nullsFirst(
    comparingInt(String::length).thenComparing(naturalOrder()));

这看起来并不比使用通用静态工厂方法的代码差，但更有趣的是，这两个比较器实际上都不适合工厂方法的模式。你必须在每个比较器上做出妥协，比如在每个字符串长度上使用装箱来比较和混淆自然顺序作为 identity() 属性比较器，以使工厂工作。所有这些都是为了节省几个字符……

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

Building a chained Comparator via a List of Functions

generics

lambda

comparator

java-8