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

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

但是，这是一个有点讨厌，我需要写出来comparing和thenComparing每次比较。理想情况下，我只需传入一个List或多个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的解决方案，最终我放弃了自定义的比较级，只是有两个方法返回一个新的比较。

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

这看起来不是利用你的通用静态工厂方法的代码差，但更重要的是有趣的，既不比较器实际上符合工厂方法的模式。您必须在每个比较器上做出妥协，比如对每个字符串长度使用装箱来比较和混淆自然顺序作为属性比较器，以使工厂正常工作。而所有这一切为了保存几个字符...