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，这有点烦人。理想情况下，我只传入一个List或多个lambdas。

类似的东西：

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

以下是我得到的最接近的部分，其中一些注释部分表示由于Generics不匹配而无效。关键点似乎是我希望传递多个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));

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类的自然顺序。

对于自然顺序，我们不需要创建比较器，我们可以使用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()属性比较器，以使工厂工作。所有这些都是为了保存一些角色......

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

2 个答案: