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

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

但是，我需要为每次比较写出比较和然后比较，这有点烦人。理想情况下，我只需输入一个列表或多个lambda。

比如：

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

下面是我得到的最接近的结果，其中一些注释部分指出了由于泛型不匹配而无效的内容。症结似乎在于我想传入多个函数

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

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

多亏了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

我不认为把这几个字母保存下来，然后再比较就值得再写一点额外的代码。由于无法使用comparingit等，您甚至会失去通用解决方案的性能，因此不得不承受不必要的装箱开销。

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

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

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

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

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

因此，您可以看到，在所有情况下，第二个比较器都是过时的--让我们看看第三个：。那么比较（Function.identity ());是一个伪装，因为标识（）不是一个真实的属性。它使链看起来有三个属性要比较，但实际上，它委托给普通的字符串比较，也就是String类的自然顺序。

对于自然顺序，我们不需要创建比较器，我们可以使用现有的比较器。

因此，得出的比较结果是：

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

或者，使用导入静态java。util。比较器* ：

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

这看起来并不比使用通用静态工厂方法的代码更糟糕，但更有趣的是，两个比较器实际上都不适合工厂方法的模式。您必须在每个比较器上做出妥协，比如在每个字符串长度上使用装箱来比较，并将自然顺序混淆为identity（）property comparator，以使工厂正常工作。所有这些都是为了节省一些字符…

Answer 2

这是可以解决的，但未经检查的铸造是必要的。首先通过以下方式声明add：

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

我替换了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));