Olá Pessoal, tudo bom?
Hoje vamos falar sobre o as coleções em Java ou Java Collections Framework. Veja na continuação:
Histórico
A Java Collections Framework (JCF) foi criada na release 2 da JDK, ou seja, há muitos anos. A definição da Oracle para a JCF é a seguinte:
Um objeto que representa um grupo de objetos. A Java Collections Framework é uma arquitetura unificada que tem a responsabilidade de representar e manipular coleções. Essa manipulação ocorre independente dos detalhes de implementação o qual são encapsulados ao usuário.
Com essa definição da Oracle sobre a JCF podem ser retirados três pontos muito importantes:
- A definição por si só é recursiva. “Um objeto que representa um grupo de objetos”
- Existe uma implementação para os tipos mais comuns de estrutura de dados
- Existe uma hierarquia muito bem amarrada de interfaces e implementações para esses tipos mais comuns, onde a classe base é a java.util.Collection além da java.util.Map
Dessa forma podemos elencar alguns pontos importantes do porque é importante aprender e utilizar a JCF:
- Reduz o esforço de programação, já que não é necessário reinventar as estruturas de dados e seus algoritmos
- Oferece uma implementação de alta performance para essas estruturas
- Estabelece uma interoperabilidade entre todas as APIs do Java, já que é um framework da base do Java
- Torna mais fácil, entender e utilizar coleções
Com o advento do Java 5, a JCF teve uma excelente adição dos Generics.
Com o advento do Java 8, a JCF teve outra excelente adição com os Streams.
Hierarquia da JCF
Diversas estruturas estão presentes na JCF, como por exemplo Lists, Queues e Sets, como a Figura 01 mostra as interfaces e classes existentes.
Todas essas interfaces e classes, provém métodos de inserção, deleção, busca, ordenação, manipulação de elementos. Lembrando também que algumas estruturas de dados permitem apenas objetos únicos, por exemplo Sets, enquanto outras estruturas permitem duplicações como ArrayLists. Cada estrutura de dados pode trazer um ganho de produtividade se utilizada corretamente.
É importante salientar que a interface Map também está presente na JCF, mas ela não é “filha” de Collection. É uma interface base fora da hierarquia da Collection.
Operações comuns
Para essa parte do artigo iremos nos basear na interface java.util.Collection. Ou seja, iremos observar sua API e trabalhar com os métodos que existem nessa interface a fim de exemplificar sua utilização.
Construindo a “Estante”
Se queremos guardar carrinhos hot wheels primeiro temos que ter um caminhão estante, senão onde iremos guardar???
Não adianta nada termos vários elementos a serem armazenados em uma coleção se não criarmos essa coleção, além disso, lembre-se uma interface não pode ser instanciada, apenas classes. A maioria das classes que estão dentro da JCF utilizam um construtor default simples para criar a coleção. Por exemplo, como criar uma instância de ArrayList:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
package br.com.mauda.collections; import java.util.ArrayList; import java.util.Collection; public class CollectionsTeste { public static void main(String[] args) { Collection<String> palavras = new ArrayList<>(); } } |
É uma prática importante criar uma instância de classe concreta e atribuir em uma interface. Além de facilitar o reuso, pois em qualquer lugar posso utilizar List ou qualquer classe que implemente a interface, existem algumas bibliotecas que obrigam aos atributos de uma classe serem do tipo da interface, como o JPA.
Adicionando carrinhos a “Estante”
Uma vez criada a collection é possível agora adicionar elementos. Para isso podemos utilizar os seguintes métodos:
boolean add(E e) – Adiciona um elemento do tipo E a collection.
boolean addAll(Collection<? extends E> c) – Adiciona todos os elementos que estão contidos na Collection do tipo E
Vamos incrementar nosso exemplo adicionando 3 strings conforme mostram as linhas 10 a 12:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package br.com.mauda.collections; import java.util.ArrayList; import java.util.Collection; public class CollectionsTeste { public static void main(String[] args) { Collection<String> palavras = new ArrayList<String>(); palavras.add("Java"); palavras.add("Collections"); palavras.add("Framework"); } } |
Verificando se já tenho esse carrinho na “Estante”
Assim como é possível adicionar elementos, é possível verificar se já existe determinado elemento ou elementos na collection. Ambos os métodos utilizam o método equals para verificar se a instância é igual. Assim é importante nas suas classes, principalmente sua entidades model sobreescrever esse método.
boolean contains(Object o) – Retorna verdadeiro se o elemento informado está dentro da coleção
boolean containsAll(Collection<?> c) – Reetorna verdadeiro se TODOS os elementos da coleção passada como parâmetro estão dentro da coleção
Vamos incrementar nosso exemplo adicionando 2 comparações conforme mostram as linhas 13 e 14. O resultado será true para a primeira comparação e false para a segunda:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
package br.com.mauda.collections; import java.util.ArrayList; import java.util.Collection; public class CollectionsTeste { public static void main(String[] args) { Collection<String> palavras = new ArrayList<String>(); palavras.add("Java"); palavras.add("Collections"); palavras.add("Framework"); System.out.println("Contém 'Collections': " + palavras.contains("Collections")); System.out.println("Contém 'Coll': " + palavras.contains("Coll")); } } |
Resultado da execução:
|
1 2 |
Contém 'Collections': true Contém 'Coll': false |
Passando por todos os carrinhos da “Estante”
Existem métodos na interface Collection que permitem você iterar sobre a coleção. Para tanto você pode utilizar de três formas distintas:
- Utilizando Iterators – Linhas 17 a 23
- Utilizando for-each (A partir do Java 5) – Linhas 25 a 29
- Utilizando Streams (A partir do Java 8) – Linhas 31 a 33
Cada exemplo foi retratado nas linhas a seguir do nosso código:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
package br.com.mauda.collections; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class CollectionsTeste { public static void main(String[] args) { Collection<String> palavras = new ArrayList<String>(); palavras.add("Java"); palavras.add("Collections"); palavras.add("Framework"); System.out.println("Contém 'Collections': " + palavras.contains("Collections")); System.out.println("Contém 'Coll': " + palavras.contains("Coll")); // Usando Iterator Iterator<String> iterator = palavras.iterator(); System.out.println("\nUtilizando Iterator:"); while (iterator.hasNext()) { String palavra = iterator.next(); System.out.println(palavra); } // Usando For Each System.out.println("\nUtilizando ForEach:"); for (String palavra : palavras) { System.out.println(palavra); } // Usando Streams System.out.println("\nUtilizando Streams:"); palavras.stream().forEach(p -> System.out.println(p)); } } |
Resultado da execução:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
Contém 'Collections': true Contém 'Coll': false Utilizando Iterator: Java Collections Framework Utilizando ForEach: Java Collections Framework Utilizando Streams: Java Collections Framework |
Doando um Carrinho ou a coleção inteira
Pode ser necessário a remoção de um elemento da collection ou até mesmo a limpeza total, deletando todos os elementos existentes. Para tanto existem os métodos abaixo que auxiliam nessa missão:
void clear() – remove todos os elementos de uma collection
boolean remove(Element e) – remove o elemento e se estiver presente na coleção. É retornado true se o elemento estava presente
boolean removeAll(Collection c) – remove da collection todos os elementos que foram passados como parâmetro retornando true se algum elemento estava presente
boolean removeIf(Predicate filter) – remove da collection os elementos que atendem o predicado. Para maior detalhe verificar o artigo removeIf
Abaixo iremos colocar os métodos clear e remove(Element) para mostrar a remoção da string Collection e da limpeza total da lista:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
package br.com.mauda.collections; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class CollectionsTeste { public static void main(String[] args) { Collection<String> palavras = new ArrayList<String>(); palavras.add("Java"); palavras.add("Collections"); palavras.add("Framework"); System.out.println("Contém 'Collections': " + palavras.contains("Collections")); System.out.println("Contém 'Coll': " + palavras.contains("Coll")); // Usando Iterator Iterator<String> iterator = palavras.iterator(); System.out.println("\nUtilizando Iterator:"); while (iterator.hasNext()) { String palavra = iterator.next(); System.out.println(palavra); } palavras.remove("Collections"); // Usando For Each System.out.println("\nUtilizando ForEach:"); for (String palavra : palavras) { System.out.println(palavra); } palavras.clear(); // Usando Streams System.out.println("\nUtilizando Streams:"); palavras.stream().forEach(p -> System.out.println(p)); } } |
Resultado da execução:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Contém 'Collections': true Contém 'Coll': false Utilizando Iterator: Java Collections Framework Utilizando ForEach: Java Framework Utilizando Streams: |
Outras formas de brincar
Por fim, existem alguns métodos que podemos utilizar para realizar algumas outras comparações.
isEmpty() – Retorna true se a collection está vazia
size() – Retorna um número inteiro com a quantidade de elementos dentro da collection
Para a fim de testar colocamos alguns pontos relacionados a collection vazia e ao seu tamanho:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
package br.com.mauda.collections; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class CollectionsTeste { public static void main(String[] args) { Collection<String> palavras = new ArrayList<String>(); palavras.add("Java"); palavras.add("Collections"); palavras.add("Framework"); System.out.println("Contém 'Collections': " + palavras.contains("Collections")); System.out.println("Contém 'Coll': " + palavras.contains("Coll")); // Usando Iterator Iterator<String> iterator = palavras.iterator(); System.out.println("\nUtilizando Iterator:"); System.out.println("Tamanho da Collection: " + palavras.size()); System.out.println("Collection Vazia? " + palavras.isEmpty()); while (iterator.hasNext()) { String palavra = iterator.next(); System.out.println(palavra); } palavras.remove("Collections"); // Usando For Each System.out.println("\nUtilizando ForEach:"); System.out.println("Tamanho da Collection: " + palavras.size()); System.out.println("Collection Vazia? " + palavras.isEmpty()); for (String palavra : palavras) { System.out.println(palavra); } palavras.clear(); // Usando Streams System.out.println("\nUtilizando Streams:"); System.out.println("Tamanho da Collection: " + palavras.size()); System.out.println("Collection Vazia? " + palavras.isEmpty()); palavras.stream().forEach(p -> System.out.println(p)); } } |
Resultado da execução:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
Contém 'Collections': true Contém 'Coll': false Utilizando Iterator: Tamanho da Collection: 3 Collection Vazia? false Java Collections Framework Utilizando ForEach: Tamanho da Collection: 2 Collection Vazia? false Java Framework Utilizando Streams: Tamanho da Collection: 0 Collection Vazia? true |
finnaly{
Duvidas ou sugestões? Deixe seu feedback! Isso ajuda a saber a sua opinião sobre os artigos e melhorá-los para o futuro! Isso é muito importante!
Até um próximo post!
Leave a Reply