CodeGym /Cursos Java /Módulo 3 /Classe CollectionUtils do Apache Commons

Classe CollectionUtils do Apache Commons

Módulo 3
Nível 20 , Lição 4
Disponível

Introdução ao CollectionUtils

Outra classe utilitária genérica que contém muitos métodos úteis:

addAll(Collection<C> collection, C...elements) Adiciona todos os elementos da matriz C à coleção
addIgnoreNull(coleção Collection<T>, objeto T) Adiciona um elemento se não for nulo
contémAll(Coleção<?>coll1, Coleção<?>coll2) Verifica se a coleção1 contém todos os elementos da coleção2
contémAny(Coleção<?>coll1, Coleção<?>coll2) Verifica se a coleção1 contém pelo menos um elemento da coleção2
countMatches(Iterable<C> input, Predicate<? super C> predicate) Conta quantos elementos em uma coleção satisfazem uma regra de predicado
disjunction(Iterable<? extends O> a, Iterable<? extends O> b) Retorna objetos que estão em apenas uma coleção, mas não em ambas
interseção(Iterável<? estende O> a, Iterável<? estende O> b) Retorna uma coleção de objetos que fazem parte de ambas as coleções ao mesmo tempo
union(Iterable<? extends O> a, Iterable<? extends O> b) Retorna uma coleção de objetos que fazem parte de pelo menos uma coleção
coleçãovazia() Retorna uma coleção vazia especial
emptyIfNull(Coleção<T> coleção) Retorna uma coleção vazia se coleção == null
existe(Iterable<C> input, Predicate<? super C> predicate) Verifica se existe um elemento na coleção que satisfaça a regra do predicado
extractSingleton(coleção<E> coleção) Retorna o único elemento da coleção
filter(Iterable<T> collection, Predicate<? super T> predicate) Filtra os elementos de uma coleção
find(Iterable<T> collection, Predicate<? super T> predicate) Procurando elementos de uma coleção
isEmpty(Collection<?>coll) Verifica se a coleção está vazia
isEqualCollection(Coleção<?> a, Coleção<?> b) Compara coleções
isFull(Collection<? extends Object> coll) Verifica se um elemento ainda pode ser adicionado à coleção
isNotEmpty(Collection<?>coll) Verifique se a coleção não está vazia
isSubCollection(Coleção<?> a, Coleção<?> b) Verifica se a coleção B está na coleção A
matchAll(Iterable<C> input, Predicate<? super C> predicate) Verifica se todos os elementos de uma coleção satisfazem uma regra de predicado
removeAll(Coleção<E> coleção, Coleção<?> remover) Remove todos os elementos da coleção
reterAll(Coleção<C> coleção, Coleção<?> reter) Retorna uma coleção contendo todos os elementos da coleção que também estão contidos em reter
reverseArray(Object[] array) Inverte uma matriz para trás
unmodificávelCollection(Collection<? extends C> collection) Retorna um wrapper sobre a coleção. Qualquer tentativa de modificar a coleção gerará uma exceção.

Vejamos alguns métodos.

Maneiras de verificar se uma coleção está vazia

Veja como é fácil determinar se uma coleção está vazia:

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

É igualmente fácil verificar se uma coleção não está vazia:

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

Exemplos:

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

Um guia para coleções do Apache Commons CollectionUtils

Operações em conjuntos

Se você teve que lidar com a teoria dos conjuntos, sabe que existem 4 operações básicas sobre conjuntos: união, interseção, diferença e disjunção.

Para essas operações, a classe CollectionUtils possui 4 métodos:

  • União()
  • interseção()
  • disjunção()
  • subtrair()

Abaixo estão alguns exemplos simples:

Uma associação

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]

interseção

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]

Disjunção

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]

Diferença (dedução)

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]

Operações em sets, continuação

Este exemplo mostra como usar os quatro métodos acima para trabalhar com duas coleções:

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

Nosso 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}

Você pode experimentar esses métodos por conta própria.

Método não modificávelCollection()

Às vezes, precisamos implementar métodos de interface que precisam retornar coleções de dados internos de nossos objetos. E como os dados são internos, não queremos que ninguém os altere em algum lugar.

Ou recebemos em algum lugar uma coleção que não precisa ser alterada, mas somos forçados a passá-la para algum método de terceiros. Onde está a garantia de que ele não vai mudar isso?

Para dormir pacificamente, a coleção pode ser empacotada em um wrapper especial que lançará uma exceção ao tentar modificar a coleção.

Exemplo:

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]

O método Collections.unmodifiableCollection() retorna um wrapper sobre a coleção passada para ele. Se você chamar seus métodos get() , size() , tudo funcionará. No entanto, ao chamar os métodos add() , set() , remove() , você receberá uma exceção.

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

Na verdade, o método já está marcado como obsoleto e é recomendável usar Collections.unmodifiableCollection(Collection<? extends T> c) .

Collection<String> firstCollection = new ArrayList<String>();
Collection<String> secondCollection =
Collections.unmodifiableCollection(firstCollection);
Comentários
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION