Clase CollectionUtils de Apache Commons

Introducción a CollectionUtils

Otra clase de utilidad genérica que contiene muchos métodos útiles:

Veamos algunos métodos.

Formas de comprobar si una colección está vacía

Así de fácil es determinar si una colección está vacía:

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

Es igual de fácil verificar que una colección no esté vacía:

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

Ejemplos:

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

Una guía para las colecciones de Apache Commons CollectionUtils

Operaciones sobre conjuntos

Si tuviste que lidiar con la teoría de conjuntos, entonces sabes que hay 4 operaciones básicas en conjuntos: unión, intersección, diferencia y disyunción.

Para estas operaciones, la clase CollectionUtils tiene 4 métodos:

• Unión()
• intersección()
• disyunción()
• sustraer()

A continuación se muestran algunos ejemplos simples:

Una asociación

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]

intersección

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]

Disyunción

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]

Diferencia (deducción)

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]

Operaciones en conjuntos, continuación

Este ejemplo muestra cómo usar los cuatro métodos anteriores para trabajar con dos colecciones:

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

Nuestro resultado:

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}

Puedes experimentar con estos métodos por tu cuenta.

Método no modificableCollection()

A veces necesitamos implementar métodos de interfaz que necesitan devolver colecciones de datos internos de nuestros objetos. Y dado que los datos son internos, no queremos que nadie los cambie en ninguna parte.

O tenemos una colección en algún lugar que no necesita ser cambiada, pero nos vemos obligados a pasarla a algún método de terceros. ¿Dónde está la garantía de que no lo cambiará?

Para poder dormir tranquilo, la colección se puede envolver en un envoltorio especial que lanzará una excepción al intentar modificar la colección.

Ejemplo:

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]

El método Collections.unmodifiableCollection() devuelve un contenedor sobre la colección que se le pasa. Si llama a sus métodos get() , size() , entonces todo funcionará. Sin embargo, al llamar a los métodos add() , set() , remove() , obtendrá una excepción.

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

De hecho, el método ya está marcado como obsoleto y se recomienda usar Collections.unmodifiableCollection(Collection<? extends T> c) en su lugar .

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