TOC

Guava, das Kochbuch bestellt

Bestellkochbuch für Guaven

1. Einführung

Dieses Kochbuch zeigthow to use the Guava style Ordering and Comparators. Es setzt das Kochbuch- und Beispielfokusformat fort, das ich inthe previous post about Guava collections gestartet habe.

2. Das Kochbuch

Umgang mit Nullen in einer Sammlung

Nullen zuerst 

List toSort = Arrays.asList(3, 5, 4, null, 1, 2);
Collections.sort(toSort, Ordering.natural().nullsFirst());
assertThat(toSort.get(0), nullValue());

Nullen zuletzt 

List toSort = Arrays.asList(3, 5, 4, null, 1, 2);
Collections.sort(toSort, Ordering.natural().nullsLast());
assertThat(toSort.get(toSort.size() - 1), nullValue());

natürliche Ordnung 

List toSort = Arrays.asList(3, 5, 4, 1, 2);
Collections.sort(toSort, Ordering.natural());

assertTrue(Ordering.natural().isOrdered(toSort));

Verkettung von 2 Bestellungen 

List toSort = Arrays.asList(3, 5, 4, 1, 2);
Collections.sort(toSort, Ordering.natural().reverse());

Bestellung umkehren 

List toSort = Arrays.asList(3, 5, 4, null, 1, 2);
Collections.sort(toSort, Ordering.natural().nullsLast().reverse());
assertThat(toSort.get(0), nullValue());

Sonderanfertigung - Saiten nach Länge 

private class OrderingByLenght extends Ordering {
    @Override
    public int compare(String s1, String s2) {
        return Ints.compare(s1.length(), s2.length());
    }
}
List toSort = Arrays.asList("zz", "aa", "b", "ccc");
Ordering byLength = new OrderingByLenght();
Collections.sort(toSort, byLength);

Ordering expectedOrder = Ordering.explicit(Lists.newArrayList("b", "zz", "aa", "ccc"));
assertTrue(expectedOrder.isOrdered(toSort))

Überprüfung der expliziten Reihenfolge 

List toSort = Arrays.asList("zz", "aa", "b", "ccc");
Ordering byLength = new OrderingByLenght();
Collections.sort(toSort, byLength);

Ordering expectedOrder = Ordering.explicit(Lists.newArrayList("b", "zz", "aa", "ccc"));
assertTrue(expectedOrder.isOrdered(toSort));

Überprüfen der Zeichenfolgenreihenfolge 

List toSort = Arrays.asList(3, 5, 4, 2, 1, 2);
Collections.sort(toSort, Ordering.natural());

assertFalse(Ordering.natural().isStrictlyOrdered(toSort));

Nachbestellung 

List toSort = Arrays.asList("zz", "aa", "b", "ccc");
Ordering byLength = new OrderingByLenght();
Collections.sort(toSort, byLength.compound(Ordering.natural()));

Ordering expectedOrder = Ordering.explicit(Lists.newArrayList("b", "aa", "zz", "ccc"));
assertTrue(expectedOrder.isOrdered(toSort));

komplexes kundenspezifisches Bestellbeispiel - mit Verkettung 

List toSort = Arrays.asList("zz", "aa", null, "b", "ccc");
Collections.sort(toSort,
    new OrderingByLenght().reverse().compound(Ordering.natural()).nullsLast());
System.out.println(toSort);

Sortieren mit der Darstellung vontoString

List toSort = Arrays.asList(1, 2, 11);
Collections.sort(toSort, Ordering.usingToString());

Ordering expectedOrder = Ordering.explicit(Lists.newArrayList(1, 11, 2));
assertTrue(expectedOrder.isOrdered(toSort));

sortieren, dann finden (binäre Suche) 

List toSort = Arrays.asList(1, 2, 11);
Collections.sort(toSort, Ordering.usingToString());
int found = Ordering.usingToString().binarySearch(toSort, 2);
System.out.println(found);

finde min / max ohne sortieren zu müssen (schneller) 

List toSort = Arrays.asList(2, 1, 11, 100, 8, 14);
int found = Ordering.usingToString().min(toSort);
assertThat(found, equalTo(1));

Erstellen einer sortierten Kopie der Liste aus einer Bestellung 

List toSort = Arrays.asList("aa", "b", "ccc");
List sortedCopy = new OrderingByLenght().sortedCopy(toSort);

Ordering expectedOrder = Ordering.explicit(Lists.newArrayList("b", "aa", "ccc"));
assertFalse(expectedOrder.isOrdered(toSort));
assertTrue(expectedOrder.isOrdered(sortedCopy));

Erstellen einer sortierten Teilkopie - die wenigsten Elemente 

List toSort = Arrays.asList(2, 1, 11, 100, 8, 14);
List leastOf = Ordering.natural().leastOf(toSort, 3);
List expected = Lists.newArrayList(1, 2, 8);
assertThat(expected, equalTo(leastOf));

Bestellung über Zwischenfunktion 

List toSort = Arrays.asList(2, 1, 11, 100, 8, 14);
Ordering ordering = Ordering.natural().onResultOf(Functions.toStringFunction());
List sortedCopy = ordering.sortedCopy(toSort);

List expected = Lists.newArrayList(1, 100, 11, 14, 2, 8);
assertThat(expected, equalTo(sortedCopy));





-note: Die Sortierlogik führt zuerst die Zahlen durch die Funktion - wandelt sie in Strings um - und sortiert dann mit natürlicher Reihenfolge auf den Strings 








3. Weitere Guaven-Kochbücher 






Guava ist eine umfassende und fantastisch nützliche Bibliothek - hier sind einige weitere APIs, die in Kochbuchform behandelt werden: 











Genießen. 










4. Fazit 






Dieses experimentelle Format - das Kochbuch - hat einen klaren Fokus - Einfachheit und Geschwindigkeit, daher haben die meisten Rezepteno additional explanation other than the code example itself. 






Und wie ich bereits erwähnt habe - dies alsa living document - sind neue Beispiele und Anwendungsfälle in den Kommentaren willkommen, und ich werde weiterhin meine eigenen hinzufügen, wenn ich auf sie stoße. 






Die Implementierung all dieser Beispiele und Codefragmentecan be found over on GitHub - dies ist ein Maven-basiertes Projekt, daher sollte es einfach zu importieren und auszuführen sein, wie es ist. 























































Related