TOC

Livre de recettes de commande de goyave

Livre de recettes de commande de goyave

1. introduction

Ce livre de recettes illustrehow to use the Guava style Ordering and Comparators. Il continue le livre de recettes et l'exemple de format de focus que j'ai commencé dansthe previous post about Guava collections.

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 en utilisant la représentationtoString 

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





-note: 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 extrêmement utile. Voici quelques API supplémentaires couvertes sous forme de livre de recettes: 











Prendre plaisir. 










4. Conclusion 






Ce format expérimental - le livre de recettes - a un objectif clair - simplicité et rapidité, de sorte que la plupart des recettes ont desno additional explanation other than the code example itself. 






Et comme je l'ai mentionné précédemment - ceci en tant quea living document - 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 codecan be found over on GitHub - il s'agit d'un projet basé sur Maven, il devrait donc être facile à importer et à exécuter tel quel. 























































Related