Classe CollectionUtils d'Apache Commons

Introduction à CollectionUtils

Une autre classe utilitaire générique qui contient de nombreuses méthodes utiles :

Regardons quelques méthodes.

Façons de vérifier si une collection est vide

Voici à quel point il est facile de déterminer si une collection est vide :

CollectionUtils.isEmpty(null); // true
CollectionUtils.isEmpty(new LinkedList<>()); // true
CollectionUtils.isEmpty(Collections.singleton(new int[]{2, 1})); // false

Il est tout aussi simple de vérifier qu'une collection n'est pas vide :

CollectionUtils.isNotEmpty(null); // false
CollectionUtils.isNotEmpty(new LinkedList<>()); // false
CollectionUtils.isNotEmpty(Collections.singleton(new int[]{2, 1})); // true

Exemples:

User ivan = new User("Ivan", "ivan@email.com");
User petr = new User("Petr", "petr@email.com");

List<User> users = new ArrayList<>();

System.out.println(CollectionUtils.isEmpty(users)); // true
System.out.println(CollectionUtils.isNotEmpty(users)); // false

users.add(ivan);
users.add(petr);

System.out.println(CollectionUtils.isEmpty(users)); // false
System.out.println(CollectionUtils.isNotEmpty(users)); // true

users = null;
System.out.println(CollectionUtils.isEmpty(users)); // true
System.out.println(CollectionUtils.isNotEmpty(users)); // false

Un guide des collections Apache Commons CollectionUtils

Opérations sur les ensembles

Si vous deviez vous occuper de la théorie des ensembles, alors vous savez qu'il existe 4 opérations de base sur les ensembles : l'union, l'intersection, la différence et la disjonction.

Pour ces opérations, la classe CollectionUtils dispose de 4 méthodes :

• syndicat()
• intersection()
• disjonction()
• soustraire()

Ci-dessous quelques exemples simples :

Une association

List<String> firstList = Arrays.asList("1", "2", "3", "4", "5", "6");
List<String> secondList = Arrays.asList("2", "3", "6", "7", "8", "9");

//combine two sets
Collection<String> result = CollectionUtils.union(firstList, secondList);
System.out.println(ArrayUtils.toString(result));     //[1, 2, 3, 4, 5, 6, 7, 8, 9]

intersection

List<String> firstList = Arrays.asList("A", "B", "C", "D", "E", "F");
List<String> secondList = Arrays.asList("B", "D", "F", "G", "H", "K");

//intersections of two sets
Collection<String> result = CollectionUtils.intersection(firstList, secondList);
System.out.println(ArrayUtils.toString(result));     //[B, D, F]

Disjonction

List<String> firstList = Arrays.asList("1", "2", "3", "4", "5", "6");
List<String> secondList = Arrays.asList("2", "3", "6", "7", "8", "9");

//disjunction
Collection<String> result = CollectionUtils.disjunction(firstList, secondList);
System.out.println(ArrayUtils.toString(result)); //[1, 4, 5, 7, 8, 9]

Différence (déduction)

List<String> firstList = Arrays.asList("1", "2", "3", "4", "5", "6");
List<String> secondList = Arrays.asList("2", "3", "6", "7", "8", "9");

//difference
Collection<String> result = CollectionUtils.subtract(firstList, secondList);
System.out.println(ArrayUtils.toString(result)); // [1, 4, 5]

Opérations sur les décors, suite

Cet exemple montre comment utiliser les quatre méthodes ci-dessus pour travailler avec deux collections :

List<Integer> firstList = Arrays.asList(1, 2, 3, 3, 4, 5);
List<Integer> secondList = Arrays.asList(3, 4, 4, 5, 6, 7);

Collection<Integer> union = CollectionUtils.union(firstList, secondList); // An association
Collection<Integer> intersection = CollectionUtils.intersection(firstList, secondList); // Intersection
Collection<Integer> disjunction = CollectionUtils.disjunction(firstList, secondList); // disjunction
Collection<Integer> subtract = CollectionUtils.subtract(firstList, secondList); // Difference

System.out.println("firstList: " + ArrayUtils.toString(firstList.toArray()));
System.out.println("secondList: " + ArrayUtils.toString(secondList.toArray()));

System.out.println("An association: " + ArrayUtils.toString(union.toArray()));
System.out.println("Intersection: " + ArrayUtils.toString(intersection.toArray()));
System.out.println("Disjunction: " + ArrayUtils.toString(disjunction.toArray()));
System.out.println("Difference: " + ArrayUtils.toString(subtract.toArray()));

Notre résultat :

firstList: {1,2,3,3,4,5}
secondList: {3,4,4,5,6,7}
An association: {1,2,3,3,4,4,5,6,7}
intersection: {3,4,5}
Disjunction: {1,2,3,4,6,7}
Difference: {1,2,3}

Vous pouvez expérimenter ces méthodes par vous-même.

Méthode unmodifiableCollection()

Parfois, nous devons implémenter des méthodes d'interface qui doivent renvoyer des collections de données internes de nos objets. Et puisque les données sont internes, nous ne voulons pas que quiconque les modifie quelque part.

Ou nous avons reçu quelque part une collection qui n'a pas besoin d'être modifiée, mais qui est obligée de la transmettre à une méthode tierce. Où est la garantie qu'il ne le changera pas ?

Afin de dormir paisiblement, la collection peut être enveloppée dans un emballage spécial qui lèvera une exception lors de la tentative de modification de la collection.

Exemple:

Collection<String> firstCollection = new ArrayList<String>();
Collection<String> secondCollection = Collections.unmodifiableCollection(firstCollection);
firstCollection.add("hello");
firstCollection.add("from");
firstCollection.add("codeGym");

//secondCollection.add("have a error");
System.out.println(secondCollection); //[hello, from, codeGym]

La méthode Collections.unmodifiableCollection() renvoie un wrapper sur la collection qui lui est transmise. Si vous appelez ses méthodes get() , size() , alors tout fonctionnera. Cependant, lors de l'appel des méthodes add() , set() , remove() , vous obtiendrez une exception.

java.lang.UnsupportedOperationException
at org.apache.commons.collections.collection.UnmodifiableCollection.add(UnmodifiableCollection.java:75)

En fait, la méthode est déjà marquée comme obsolète et il est recommandé d'utiliser Collections.unmodifiableCollection(Collection<? extend T> c) à la place .

Collection<String> firstCollection = new ArrayList<String>();
Collection<String> secondCollection =
Collections.unmodifiableCollection(firstCollection);