通過函數列表構建鏈式比較器

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

這看起來不是利用你的通用靜態工廠方法的代碼差，但更重要的是有趣的，既不比較器實際上符合工廠方法的模式。您必須在每個比較器上做出妥協，比如對每個字符串長度使用裝箱來比較和混淆自然順序作爲屬性比較器，以使工廠正常工作。而所有這一切爲了保存幾個字符...