Un guide pour Apache Commons Collections CollectionUtils

Un guide de la collection de collections Apache CommonsUtils

1. Vue d'ensemble

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

2. Dépendances Maven

Nous devons ajouter la dépendance suivante pour commencer avecCollectionUtils:


    org.apache.commons
    commons-collections4
    4.1

La dernière version de la bibliothèque peut être trouvéehere.

3. Installer

AjoutonsCustomer etAddress classes:

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 instancesCustomer etList 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 classeApache Commons CollectionUtils.

4.1. Ajouter uniquement des éléments non nuls

Nous pouvons utiliser la méthodeCollectionUtils’s addIgnoreNull 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 second 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 lenull n'a pas été ajouté à la liste.

4.2. Rassembler les listes

We can use collate method to collate two already sorted lists. 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éthodetransform 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 untransformer 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 des objets

Using filter we can remove objects which do not satisfy a given condition from a list. La méthode prend la liste comme premier argument et unPredicate comme deuxième argument.

The filterInverse method does the opposite. Il supprime les objets de la liste lorsquePredicate renvoie vrai.

Les deuxfilter etfilterInverse renvoienttrue si la liste d'entrée a été modifiée, c'est-à-dire si au moins un objet a été filtré 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 utiliserselect etselectRejected 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

The isNotEmpty method is quite handy when we want to check if there is at least single element in a list. 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));
}

The isEmpty does the opposite. 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 utiliserisSubCollection pour vérifier si une collection est contenue dans une autre collection. isSubCollection prend deux collections comme arguments et renvoietrue 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));
}

Une collection est une sous-collection d'une autre collection si le nombre d'occurrences d'un objet dans la première collection est inférieur ou égal au nombre d'occurrences dans la deuxième collection.

4.7. Intersection de collections

We can use CollectionUtils.intersection method to get the intersection of two collections. Cette méthode prend deux collections et retourne une collection d'éléments dont sont communs dans les deux collections d'entrée:

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

Le nombre d'occurrences d'un élément dans la collection résultante est au minimum le nombre d'occurrences dans chacune des collections données.

4.8. Soustraction de collections

CollectionUtils.subtract prend deux collections en entrée et retourne une collection qui contient des éléments qui sont là dans la première collection mais pas dans la deuxième collection:

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

Le nombre d'occurrences d'une collection dans le résultat correspond au nombre d'occurrences de la première collection moins le nombre d'occurrences de la seconde collection.

4.9. Union des collections

CollectionUtils.union fait l'union de deux collections et renvoie une collection qui contient tous les éléments qui se trouvent dans la première ou la deuxième collection.

@Test
public void givenTwoLists_whenUnioned_thenCheckElementPresentInResult() {
    Collection union = CollectionUtils.union(list1, list2);

    assertTrue(union.contains(customer1));
    assertTrue(union.contains(customer4));
}

Le nombre d'occurrences d'un élément dans la collection résultante est le maximum du nombre d'occurrences dans chacune des collections données.

5. Conclusion

Et nous avons terminé.

Nous avons passé en revue certaines des méthodes couramment utilisées deCollectionUtils - ce qui est très utile pour éviter le passe-partout lorsque nous travaillons avec des collections dans nos projets Java.

Comme d'habitude, le code est disponibleover on GitHub.

TOC