Guava Ordering Cookbook

1. Introduzione

Questo libro di cucina illustra come utilizzare Ordinamento e comparatori in stile Guava . Continua il libro di cucina e il formato focus di esempio che ho iniziato nel post precedente sulle collezioni Guava.

2. Il ricettario

trattare con i valori nulli in una raccolta

prima i null

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

i null durano

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

ordinamento naturale

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

concatenamento di 2 ordini

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

invertire un ordine

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

ordine personalizzato: stringhe per lunghezza

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

controllo dell'ordine esplicito

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

controllo dell'ordine delle stringhe

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

ordinamento secondario

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

esempio di ordinamento personalizzato complesso - con concatenamento

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

ordinare utilizzando la rappresentazione toString

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

ordina, quindi trova (ricerca binaria)

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

trova min / max senza dover ordinare (più veloce)

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

creazione di una copia ordinata dell'elenco da un ordinamento

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

creazione di una copia parziale ordinata - il minor numero di elementi

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

ordinazione tramite Funzione intermediaria

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

- nota : la logica di ordinamento eseguirà prima i numeri attraverso la funzione - trasformandoli in stringhe - quindi ordinerà con ordine naturale sulle stringhe

3. Altri libri di cucina Guava

Guava è una libreria completa e straordinariamente utile: ecco alcune altre API trattate in formato ricettario:

  • Ricettario Funzionale Guava

  • Ricettario delle collezioni Guava

Godere.

4. Conclusione

Questo formato sperimentale - il ricettario - ha un chiaro obiettivo: semplicità e velocità, quindi la maggior parte delle ricette non ha spiegazioni aggiuntive oltre all'esempio di codice stesso .

E come ho detto prima - questo come un documento vivente - nuovi esempi e casi d'uso sono i benvenuti nei commenti, e continuerò ad aggiungere i miei mentre li incontro.

L'implementazione di tutti questi esempi e frammenti di codice può essere trovata su GitHub : questo è un progetto basato su Maven, quindi dovrebbe essere facile da importare ed eseguire così com'è.