Un guide de la collection Apache Commons Collections

Cet article fait partie d'une série: • Apache Commons Collections Bag

• SetUtils des collections Apache Commons

• OrderedMap des collections Apache Commons

• Collections Apache Commons BidiMap

• Un guide sur Apache Commons Collections CollectionUtils (article actuel) • Apache Commons Collections MapUtils

• Guide d'Apache Commons CircularFifoQueue

1. Vue d'ensemble

En termes simples, Apache CollectionUtils fournit des méthodes utilitaires pour les opérations courantes qui couvrent un large éventail de cas d'utilisation et aide à éviter d'écrire du code standard. La bibliothèque cible les anciennes versions de JVM car actuellement, des fonctionnalités similaires sont fournies par l' API Stream de Java 8 .

2. Dépendances de Maven

Nous devons ajouter la dépendance suivante pour démarrer avec CollectionUtils:

 org.apache.commons commons-collections4 4.1 

La dernière version de la bibliothèque est disponible ici.

3. Configuration

Ajoutons des classes de client et d' adresse:

public class Customer { private Integer id; private String name; private Address address; // standard getters and setters } public class Address { private String locality; private String city; // standard getters and setters }

Nous garderons également à portée de main les instances Customer et List suivantes prêtes à tester notre implémentation:

Customer customer1 = new Customer(1, "Daniel", "locality1", "city1"); Customer customer2 = new Customer(2, "Fredrik", "locality2", "city2"); Customer customer3 = new Customer(3, "Kyle", "locality3", "city3"); Customer customer4 = new Customer(4, "Bob", "locality4", "city4"); Customer customer5 = new Customer(5, "Cat", "locality5", "city5"); Customer customer6 = new Customer(6, "John", "locality6", "city6"); List list1 = Arrays.asList(customer1, customer2, customer3); List list2 = Arrays.asList(customer4, customer5, customer6); List list3 = Arrays.asList(customer1, customer2); List linkedList1 = new LinkedList(list1);

4. CollectionUtils

Passons en revue certaines des méthodes les plus utilisées dans la classe Apache Commons CollectionUtils .

4.1. Ajouter uniquement des éléments non nuls

Nous pouvons utiliser la méthode addIgnoreNull de CollectionUtils pour ajouter uniquement des éléments non nuls à une collection fournie.

Le premier argument de cette méthode est la collection à laquelle nous voulons ajouter l'élément et le deuxième argument est l'élément que nous voulons ajouter:

@Test public void givenList_whenAddIgnoreNull_thenNoNullAdded() { CollectionUtils.addIgnoreNull(list1, null); assertFalse(list1.contains(null)); }

Notez que la valeur null n'a pas été ajoutée à la liste.

4.2. Rassembler les listes

Nous pouvons utiliser la méthode collate pour assembler deux listes déjà triées. Cette méthode prend les deux listes, que nous voulons fusionner, comme arguments et renvoie une seule liste triée:

@Test public void givenTwoSortedLists_whenCollated_thenSorted() { List sortedList = CollectionUtils.collate(list1, list2); assertEquals(6, sortedList.size()); assertTrue(sortedList.get(0).getName().equals("Bob")); assertTrue(sortedList.get(2).getName().equals("Daniel")); }

4.3. Transformer des objets

Nous pouvons utiliser la méthode transform pour transformer des objets de classe A en différents objets de classe B. Cette méthode prend une liste d'objets de classe A et un transformateur comme arguments.

Le résultat de cette opération est une liste d'objets de classe B:

@Test public void givenListOfCustomers_whenTransformed_thenListOfAddress() { Collection addressCol = CollectionUtils.collect(list1, new Transformer() { public Address transform(Customer customer) { return customer.getAddress(); } }); List addressList = new ArrayList(addressCol); assertTrue(addressList.size() == 3); assertTrue(addressList.get(0).getLocality().equals("locality1")); }

4.4. Filtrage d'objets

En utilisant le filtre, nous pouvons supprimer les objets qui ne satisfont pas à une condition donnée d'une liste . La méthode prend la liste comme premier argument et un prédicat comme deuxième argument.

La méthode filterInverse fait le contraire. Il supprime les objets de la liste lorsque le prédicat renvoie true.

Les deux filtres et filterInverse retour vrai si la liste d'entrée a été modifié, par exemple , si au moins un objet a été filtré à partir de la liste:

@Test public void givenCustomerList_WhenFiltered_thenCorrectSize() { boolean isModified = CollectionUtils.filter(linkedList1, new Predicate() { public boolean evaluate(Customer customer) { return Arrays.asList("Daniel","Kyle").contains(customer.getName()); } }); assertTrue(linkedList1.size() == 2); }

Nous pouvons utiliser select et selectRejected si nous voulons que la liste résultante soit renvoyée plutôt qu'un drapeau booléen.

4.5. Vérification du non-vide

La méthode isNotEmpty est assez pratique lorsque nous voulons vérifier s'il y a au moins un élément dans une liste. L'autre façon de vérifier la même chose est:

boolean isNotEmpty = (list != null && list.size() > 0);

Bien que la ligne de code ci-dessus fasse la même chose, CollectionUtils.isNotEmpty maintient notre code plus propre:

@Test public void givenNonEmptyList_whenCheckedIsNotEmpty_thenTrue() { assertTrue(CollectionUtils.isNotEmpty(list1)); }

Le isEmpty fait le contraire. Il vérifie si la liste donnée est nulle ou s'il n'y a aucun élément dans la liste:

List emptyList = new ArrayList(); List nullList = null; assertTrue(CollectionUtils.isEmpty(nullList)); assertTrue(CollectionUtils.isEmpty(emptyList));

4.6. Vérification de l'inclusion

Nous pouvons utiliser isSubCollection pour vérifier si une collection est contenue dans une autre collection. isSubCollection prend deux collections comme arguments et retourne true si la première collection est une sous-collection de la deuxième collection:

@Test public void givenCustomerListAndASubcollection_whenChecked_thenTrue() { assertTrue(CollectionUtils.isSubCollection(list3, list1)); }

A collection is sub-collection of another collection if the number of times an object occurs in the first collection is less than or equal to the number of times it occurs in the second collection.

4.7. Intersection of Collections

We can use CollectionUtils.intersection method to get the intersection of two collections. This method takes two collections and returns a collection of elements of which are common in both the input collections:

@Test public void givenTwoLists_whenIntersected_thenCheckSize() { Collection intersection = CollectionUtils.intersection(list1, list3); assertTrue(intersection.size() == 2); }

The number of times an element occurs in the resultant collection is a minimum of the number of times it occurs in each of the given collections.

4.8. Subtracting Collections

CollectionUtils.subtract takes two collections as input and returns a collection which contains elements which are there in the first collection but not in the second collection:

@Test public void givenTwoLists_whenSubtracted_thenCheckElementNotPresentInA() { Collection result = CollectionUtils.subtract(list1, list3); assertFalse(result.contains(customer1)); }

The number of times a collection occurs in the result is the number of times it occurs in first collection minus the number of times it occurs in the second collection.

4.9. Union of Collections

CollectionUtils.union does the union of two collections and returns a collection which contains all the elements which are there in either the first or the second collection.

@Test public void givenTwoLists_whenUnioned_thenCheckElementPresentInResult() { Collection union = CollectionUtils.union(list1, list2); assertTrue(union.contains(customer1)); assertTrue(union.contains(customer4)); }

The number of times an element occurs in the resulting collection is the maximum of the number of times it occurs in each of the given collections.

5. Conclusion

And we're done.

We went through some of the commonly used methods of CollectionUtils – which is very much useful to avoid boilerplate when we're working with collections in our Java projects.

As usual, the code is available over on GitHub.

Suivant » Apache Commons Collections MapUtils « Précédent Apache Commons Collections BidiMap