Schön, Allgemeinen Art und Weise zu Sortieren Nullen in der unteren, unabhängig?

Schreibe ich einige custom-Komparatoren, und dann möchte ich Ihnen push-null-Elemente an der Unterseite der Liste, unabhängig davon, ob ich die Sortierung auf-oder absteigend. Was ist eine gute Strategie oder das Muster für die Annäherung an diese?

Offhand:

Einfach schreibst aufsteigend
absteigend Komparatoren, die Freigabe von code
wo möglich
Delegieren die Behandlung von null zu einem anderen
Klasse, entweder durch das werfen einer NPE oder
durch den Aufruf explizit
Gehören eine aufsteigende Flagge und setzen
bedingten Logik, in ihm zu navigieren
um die null-Werte
Wrap regular Komparatoren in einem
null-handling-Klasse

Andere Strategien? Ich würde gerne hören, über Erfahrungen mit unterschiedlichen Ansätzen, und alle Fallstricke, die für die verschiedenen Strategien.

InformationsquelleAutor Carl Manaster | 2009-08-11

6

Die Letzte option gefällt mir sehr. Komparatoren sind wirklich toll zur Kette zusammen. Insbesondere können Sie auch schreiben wollen ReverseComparator sowie eine NullWrappingComparator.

EDIT: Du musst nicht schreiben diese selbst. Wenn man sich die Bestellen Klasse in der Google Collections Library finden Sie diese und allerlei andere leckereien 🙂

EDIT: Geht mehr ins detail, um zu zeigen, was ich meine über ReverseComparator...

Ein Wort der Warnung - bei der Umsetzung einer ReverseComparator, ist die Reihenfolge der Argumente statt negieren das Ergebnis, wie sonst Integer.MIN_VALUE ist "Umgekehrt" zu sich selbst.

Also diese Implementierung ist falsch (vorausgesetzt original ist der Komparator auf Rückseite):
```
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 ist, dass wir immer umkehren wollen den Vergleich, aber wenn original.compare(x, y) zurück int.MIN_VALUE, dann die schlechte comparer wird auch zurück int.MIN_VALUE ab, was falsch ist. Dies ist bedingt durch die komische Eigenschaft, dass int.MIN_VALUE == -int.MIN_VALUE.
- Ich Stimme mit allen in Ihrer Antwort, außer zu negieren das Ergebnis von vergleichen; ich wäre ziemlich unglücklich, wenn ich fand heraus, dass ein Komparator wurde die Umsetzung von integer-Vergleich mit der Subtraktion, da die Methode hat so viele Fallstricke.
- Ich denke, Sie haben mich mißverstanden. Ich werde Bearbeiten.
- Ich bin der Annahme, dass diese Antwort, weil der Verweis auf Google-Sammlungen Bestell-class - bewährten code ist die beste Lösung. Auch für die Warnung über Integer.MIN_VALUE. Aber ich Schätze @dfa-code unten, und ich wünschte, ich könnte annehmen, beide Antworten.
InformationsquelleAutor Jon Skeet

Ich Stimme mit Jon Skeet (es ist so einfach :). Ich habe versucht zu implementieren, die eine sehr einfache Dekorateur:

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 Komparator:

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

und einige test-Daten:

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

können Sie Sortieren, mit null am Ende:

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

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

oder am Anfang:

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

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

Sehr schön! Danke. Gibt es einen Grund, für nicht 0 zurückgeben, wenn beide Argumente null sind? Ich weiß, dass null-Verhalten ist nicht ganz wie in der nicht-null-Verhalten, und zu sagen, dass zwei null-Werte gleich sind, ist fraglich - aber es ist weniger fraglich, zu sagen, dass das eine das andere übersteigt?
Genau der Punkt, den ich nur aus deinem Beitrag 🙂 Einen Vergleicher sollte 0 zurück oder werfen eine Ausnahme, wenn Sie verabschiedet zwei Nullen, sonst ist es Ungehorsam, die Schnittstelle Vertrag.

InformationsquelleAutor dfa

Folgenden bis auf dfa Antwort - was ich will, ist, dass die null-Werte Sortieren Sie am Ende, ohne die Anordnung der nicht-null-Werte. So möchte ich etwas mehr entlang den Linien von:

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

Vollen Kredit der dfa, obwohl - dies ist nur eine kleine Modifikation seiner Arbeit.

Ein problem: Sie weiß nicht 0 zurückgeben, wenn man zwei Nullen.
Danke; bearbeitet mit Korrektur.

InformationsquelleAutor Carl Manaster

In Java 8 verwenden, können Sie die Komparator.nullsLast und Komparator.nullsFirst statische Methoden haben mehr null-freundlich-Komparatoren. Angenommen, Sie haben eine Fruit Klasse wie die folgenden:

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

    //Constructor and Getters
}

Wenn Sie möchten, zu Sortieren, ein paar Früchte durch Ihre Größe und legen Sie die nulls am Ende:

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

Können Sie 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]

InformationsquelleAutor Ali Dehghani

2

Konnte man immer verwenden NullComparator von commons-collections. Es gibt Sie schon länger als Google-Sammlungen.

InformationsquelleAutor Tim R

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.