Schöne allgemeine Art, Nullen ganz nach unten zu sortieren, egal?

Question

Ich schreibe einige benutzerdefinierte Vergleicher, und ich möchte, dass sie null Elemente an den unteren Rand der Liste schieben, unabhängig davon, ob ich aufsteigend oder absteigend sortiere. Was ist eine gute Strategie oder ein gutes Muster dafür?

Offhand:

• Schreiben Sie einfach getrennt auf- und absteigend Komparatoren, Code-Sharing wo möglich
• Delegate null Handhabung an einen anderen Klasse, entweder durch eine NPE oder werfen, indem sie explizit
Aufruf
• Fügen Sie ein aufsteigendes Flag hinzu und setzen Sie bedingte Logik darin, um um die Nullen
zu navigieren
• Wrap regelmäßige Komparatoren in einem null Handling-Klasse

Jede andere Strategien? Ich würde gern von irgendwelchen Erfahrungen mit verschiedenen Ansätzen und Fallstricken für die verschiedenen Strategien hören.

Answer 1

Die letzte Option gefällt mir sehr. Komparatoren sind wirklich großartig, um zusammen zu ketten. Insbesondere möchten Sie vielleicht eine ReverseComparator sowie eine NullWrappingComparator schreiben.

---

EDIT: Sie müssen dies nicht selbst schreiben. Wenn man sich die Ordering Klasse aussehen in der Google Collections Library werden Sie diese und alle möglichen anderen Leckereien finden :)

---

EDIT: mehr ins Detail gehen zu zeigen, was ich meine über ReverseComparator ...

Ein Wort der Warnung - in der Implementierung eines ReverseComparator, umgekehrte Reihenfolge der Argumente, anstatt das Ergebnis zu negieren, wie sonst Integer.MIN_VALUE ist "umgekehrt" zu sich selbst.

Also diese Implementierung falsch ist (original Annahme, daß der Komparator umgekehrt):

public int compare(T x, T y) 
{ 
    return -original.compare(x, y); 
} 

aber das ist richtig:

public int compare(T x, T y) 
{ 
    return original.compare(y, x); 
} 

Der Grund dafür ist, dass wir den Vergleich immer umkehren wollen, aber wenn zurückgibt, dann wird der schlechte Vergleicher auch Rückkehr int.MIN_VALUE, die falsch ist. Dies ist aufgrund der witzigen Eigenschaft, dass int.MIN_VALUE == -int.MIN_VALUE.

Answer 2

Ich stimme Jon Skeet (es ist so einfach :).Ich habe versucht, eine sehr einfache decorator zu implementieren:

class NullComparators { 

    static <T> Comparator<T> atEnd(final Comparator<T> comparator) { 
     return new Comparator<T>() { 

      public int compare(T o1, T o2) { 
       if (o1 == null && o2 == null) { 
        return 0; 
       } 

       if (o1 == null) { 
        return 1; 
       } 

       if (o2 == null) { 
        return -1; 
       } 

       return comparator.compare(o1, o2); 
      } 
     }; 
    } 

    static <T> Comparator<T> atBeginning(final Comparator<T> comparator) { 
     return Collections.reverseOrder(atEnd(comparator)); 
    } 
} 

gegeben ein Vergleicher:

Comparator<String> wrapMe = new Comparator<String>() { 
     public int compare(String o1, String o2) { 
      return o1.compareTo(o2); 
     } 
}; 

und einige Testdaten:

List<String> strings = Arrays.asList(null, "aaa", null, "bbb", "ccc", null); 

Sie mit Nullen am Ende sortieren:

Collections.sort(strings, NullComparators.atEnd(wrapMe)); 

oder am Anfang:

Collections.sort(strings, NullComparators.atBeginning(wrapMe)); 

 
[null, null, null, ccc, bbb, aaa] 

Answer 3

Im Anschluss an DFA Antwort auf - was ich will, ist, dass die nulls Art am Ende ohne die Reihenfolge der Nicht-NULL-Werte zu beeinflussen. Deshalb möchte ich etwas mehr nach dem Vorbild dieses:

public class NullComparatorsTest extends TestCase { 
    Comparator<String> forward = new Comparator<String>() { 
            public int compare(String a, String b) { 
             return a.compareTo(b); 
            } 
           }; 

    public void testIt() throws Exception { 
     List<String> strings = Arrays.asList(null, "aaa", null, "bbb", "ccc", null); 
     Collections.sort(strings, NullComparators.atEnd(forward)); 
     assertEquals("[aaa, bbb, ccc, null, null, null]", strings.toString()); 
     Collections.sort(strings, NullComparators.atBeginning(forward)); 
     assertEquals("[null, null, null, aaa, bbb, ccc]", strings.toString()); 
    } 
} 

public class NullComparators { 
    public static <T> Comparator<T> atEnd(final Comparator<T> comparator) { 
     return new Comparator<T>() { 
      public int compare(T a, T b) { 
       if (a == null && b == null) 
        return 0; 
       if (a == null) 
        return 1; 
       if (b == null) 
        return -1; 
       return comparator.compare(a, b); 
      } 
     }; 
    } 

    public static <T> Comparator<T> atBeginning(final Comparator<T> comparator) { 
     return new Comparator<T>() { 
      public int compare(T a, T b) { 
       if (a == null && b == null) 
        return 0; 
       if (a == null) 
        return -1; 
       if (b == null) 
        return 1; 
       return comparator.compare(a, b); 
      } 
     }; 
    } 
} 

Volle Gutschrift auf DFA, obwohl - das ist nur eine kleine Änderung seiner Arbeit.

Answer 4

Sie könnten immer NullComparator von Commons-Sammlungen verwenden. Es ist länger als Google Sammlungen.

Answer 5

In Java 8 können Sie die statischen Methoden und Comparator.nullsFirst verwenden, um mehr Null-freundliche Komparatoren zu haben. Angenommen, Sie haben eine Fruit Klasse wie folgt aus:

public class Fruit { 
    private final String name; 
    private final Integer size; 

    // Constructor and Getters 
} 

Wenn Sie durch ihre Größe ein paar Früchte sortieren und legte die null s am Ende:

List<Fruit> fruits = asList(null, new Fruit("Orange", 25), new Fruit("Kiwi", 5)); 

Sie können einfach schreiben:

Collections.sort(fruits, Comparator.nullsLast(Comparator.comparingInt(Fruit::getSize))); 

Und das Ergebnis wäre:

[Fruit{name='Kiwi', size=5}, Fruit{name='Orange', size=25}, null]