Livre de recettes de commande de goyave

1. Introduction

Ce livre de cuisine illustre comment utiliser la commande et les comparateurs de style Guava . Il continue le livre de cuisine et l'exemple de format de focus que j'ai commencé dans le précédent post sur les collections de goyaves.

2. Le livre de recettes

traiter les valeurs nulles dans une collection

NULL en premier

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

les nulls durent

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

ordre naturel

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

chaînage de 2 ordres

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

inverser une commande

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

commande personnalisée - Chaînes par longueur

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

vérification de l'ordre explicite

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

vérification de l'ordre des chaînes

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

commande secondaire

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

exemple de commande personnalisée complexe - avec chaînage

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

trier à l'aide de la représentation 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));

trier, puis trouver (recherche binaire)

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

trouver min / max sans avoir à trier (plus rapide)

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

création d'une copie triée de la liste à partir d'une commande

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

création d'une copie partielle triée - le moins d'éléments

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

commande via la fonction intermédiaire

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

- remarque : la logique de tri exécutera d'abord les nombres à travers la fonction - en les transformant en chaînes - puis triera avec un ordre naturel sur les chaînes

3. Plus de livres de cuisine sur la goyave

Guava est une bibliothèque complète et incroyablement utile - voici quelques API supplémentaires couvertes sous forme de livre de cuisine:

  • Livre de recettes fonctionnel de goyave

  • Livre de recettes des collections de goyave

Prendre plaisir.

4. Conclusion

Ce format expérimental - le livre de recettes - a un objectif clair - la simplicité et la rapidité, de sorte que la plupart des recettes n'ont aucune explication supplémentaire autre que l'exemple de code lui-même .

Et comme je l'ai déjà mentionné - il s'agit d' un document évolutif - de nouveaux exemples et cas d'utilisation sont les bienvenus dans les commentaires, et je continuerai d'ajouter les miens au fur et à mesure que je les rencontre.

L'implémentation de tous ces exemples et extraits de code peut être trouvée sur GitHub - il s'agit d'un projet basé sur Maven, il devrait donc être facile à importer et à exécuter tel quel.