Um guia para a coleção de coleções do Apache Commons

1. Visão geral

Simplificando, oApacheCollectionUtils fornece métodos utilitários para operações comuns que cobrem uma ampla gama de casos de uso e ajudam a evitar a escrita de código clichê. A biblioteca é destinada a versões JVM mais antigas porque, atualmente, uma funcionalidade semelhante é fornecida pela APIStream do Java 8.

2. Dependências do Maven

Precisamos adicionar a seguinte dependência para continuar comCollectionUtils:


    org.apache.commons
    commons-collections4
    4.1

A versão mais recente da biblioteca pode ser encontradahere.

3. Configuração

Vamos adicionarCustomer eAddress 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
}

Também manteremos em mãos as seguintes instânciasCustomer eList prontas para testar nossa implementação:

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

Vamos examinar alguns dos métodos mais usados na classeApache Commons CollectionUtils.

4.1. Adicionando apenas elementos não nulos

Podemos usar o métodoCollectionUtils’s addIgnoreNull para adicionar apenas elementos não nulos a uma coleção fornecida.

O primeiro argumento para esse método é a coleção à qual queremos adicionar o elemento e o segundo argumento é o elemento que queremos adicionar:

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

    assertFalse(list1.contains(null));
}

Observe quenull não foi adicionado à lista.

4.2. Agrupando listas

We can use collate method to collate two already sorted lists. Este método pega ambas as listas, que queremos mesclar, como argumentos e retorna uma única lista classificada:

@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. Transformando Objetos

Podemos usar o métodotransform para transformar objetos da classe A em diferentes objetos da classe B. Este método usa uma lista de objetos da classe A etransformer como argumentos.

O resultado desta operação é uma lista de objetos da 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. Filtrando Objetos

Using filter we can remove objects which do not satisfy a given condition from a list. O método leva a lista como primeiro argumento ePredicate como segundo argumento.

The filterInverse method does the opposite. Remove objetos da lista quandoPredicate retorna verdadeiro.

Ambosfilter efilterInverse retornamtrue se a lista de entrada foi modificada, ou seja, se pelo menos um objeto foi filtrado da lista:

@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);
}

Podemos usarselecteselectRejected se quisermos que a lista resultante seja retornada em vez de um sinalizador booleano.

4.5. Verificando se não está vazio

The isNotEmpty method is quite handy when we want to check if there is at least single element in a list. A outra maneira de verificar o mesmo é:

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

Embora a linha de código acima faça o mesmo,CollectionUtils.isNotEmpty mantém nosso código mais limpo:

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

The isEmpty does the opposite. Verifica se a lista fornecida é nula ou se não há nenhum elemento na lista:

List emptyList = new ArrayList<>();
List nullList = null;

assertTrue(CollectionUtils.isEmpty(nullList));
assertTrue(CollectionUtils.isEmpty(emptyList));

4.6. Verificando Inclusão

Podemos usarisSubCollection para verificar se uma coleção está contida em outra coleção. isSubCollection recebe duas coleções como argumentos e retornatrue se a primeira coleção for uma subcoleção da segunda coleção:

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

Uma coleção é uma sub-coleção de outra coleção se o número de vezes que um objeto ocorre na primeira coleção é menor ou igual ao número de vezes que ocorre na segunda coleção.

4.7. Interseção de coleções

We can use CollectionUtils.intersection method to get the intersection of two collections. Este método pega duas coleções e retorna uma coleção de elementos que são comuns em ambas as coleções de entrada:

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

O número de vezes que um elemento ocorre na coleção resultante é no mínimo o número de vezes que ocorre em cada uma das coleções especificadas.

4.8. Subtraindo coleções

CollectionUtils.subtract pega duas coleções como entrada e retorna uma coleção que contém elementos que estão na primeira coleção, mas não na segunda coleção:

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

O número de vezes que uma coleção ocorre no resultado é o número de vezes que ocorre na primeira coleção menos o número de vezes que ocorre na segunda coleção.

4.9. União de coleções

CollectionUtils.union faz a união de duas coleções e retorna uma coleção que contém todos os elementos que estão lá na primeira ou na segunda coleção.

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

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

O número de vezes que um elemento ocorre na coleção resultante é o número máximo de vezes que ocorre em cada uma das coleções especificadas.

5. Conclusão

E nós terminamos.

Passamos por alguns dos métodos comumente usados deCollectionUtils - o que é muito útil para evitar clichês quando estamos trabalhando com coleções em nossos projetos Java.

Como de costume, o código está disponívelover on GitHub.

TOC

Um guia para a coleção de coleções do Apache Commons