Vamos aprofundar nosso conhecimento e prática sobre as coleções do Java. Antes disso, é importante entender por que utilizamos coleções ao invés de arrays comuns, que são estruturas conhecidas na programação.
Os arrays são basicamente uma construção de baixo nível, apresentando inflexibilidade em alguns aspectos, como no ajuste de tamanho. Eles não possuem operações para buscar, classificar ou adicionar elementos, além de terem tamanhos fixos, o que gera uma complexidade indesejada.
Por isso, damos prioridade ao uso das **coleções **do Java.
Conhecendo tipos de coleções
Vamos explorar um pouco sobre essas coleções, os tipos mais conhecidos, como são utilizadas e como programamos com elas.
Assim como os arrays, as coleções são estruturas de dados que armazenam múltiplos elementos. No Java, as interfaces principais que declaram esses métodos são:
Entenderemos a diferença entre as três e como decidimos por uma ou outra.
Trabalhando com Listas
Basicamente, a List permite ordenação e é útil quando queremos ordenar os elementos de uma coleção desse tipo. Ela também permite duplicidade.
As implementações principais da interface List são as classes:
Usamos ArrayList quando queremos realizar buscas rápidas. Já o LinkedList é preferido quando fazemos muitas inserções e remoções.
Dependendo do caso, optamos por um ou outro. O uso mais comum é o ArrayList.
As operações mais comuns ao utilizar esse tipo de coleção são:
add para adicionar um elemento;remove para remover;contains para verificar se um elemento existe na lista;get para obter um elemento em uma posição específica esize para saber o tamanho total da lista.
Vamos praticar alguns exemplos. Acessando a IDE IntelliJ, já temos uma classe Principal e um método main. Dentro dele, simularemos a criação de uma lista de pessoas funcionárias.
Primeiro, vamos importar a classe List de java.util e declarar o tipo List, utilizando generics com os símbolos de maior e menor (<>) para indicar que é uma lista de String, pois guardaremos os nomes das pessoas funcionárias.
Nomearemos essa variável como funcionarios. A criação é feita pela classe ArrayList, com new ArrayList<>(). Também devemos importá-la.
import java.util.ArrayList;
import java.util.List;
public class Principal {
public static void main(String[] args) {
List<String> funcionarios = new ArrayList<>();
}
}
Para adicionar itens à lista, utilizamos funcionarios.add() e inserimos o nome de uma pessoa funcionária, como "João". Podemos adicionar mais, como "Maria", e incluir repetidos, como outro "João".
public static void main(String[] args) {
List<String> funcionarios = new ArrayList<>();
public static void main(String[] args) {
List<String> funcionarios = new ArrayList<>();
}
Podemos imprimir a lista com System.out.println(funcionarios)
System.out.println(funcionarios);
Com isso, veremos "João", "Maria" e "João" novamente no terminal, separados por vírgulas. A lista permite duplicados e mantém a ordem de inserção.
[João, Maria, João]
Podemos alterar esse println() e realizar outras operações, como funcionarios.getFirst() para obter o primeiro elemento. Isso retornará "João".
System.out.println(funcionarios.getFirst());
Também podemos retornar um elemento em uma posição específica. O comando funcionarios.get(1) retornará "Maria", pois a primeira posição é sempre 0.
System.out.println(funcionarios.get(1));
Trabalhando com o Set
Agora, vamos analisar a diferença do List para o próximo tipo, o Set.
O Set é usado quando a ordenação não é o foco. Ele não permite duplicidade, então não poderíamos ter dois "João". As implementações do Set incluem:
HashSet;LinkedHashSet eTreeSet.
O HashSet é o mais rápido, pois não se preocupa com ordenação e não permite duplicidade. O LinkedHashSet mantém a ordem de inserção, enquanto o TreeSet permite ordenação, mas é mais lento.
O HashSet é o mais utilizado por ser rápido e não se preocupar com a ordem.
Vamos criar um exemplo com Set, desta vez com produtos. A criação é semelhante à da lista.
Abaixo do último println(), declararemos um Set de String usando generics para produtos e utilizaremos new HashSet<>() para a implementação.
Set<String> produtos = new HashSet<>();
Para adicionar produtos, usaremos produtos.add(), como "Água", por exemplo.
produtos.add("Água");
produtos.add("Coca-cola");
Se tentarmos adicionar "Água" novamente e imprimir, não será exibido, pois não é permitida duplicidade. Vamos copiar e colar a linha referente à "Água" para verificar isso, adicionando em seguida um println() de produtos.
produtos.add("Água");
produtos.add("Coca-cola");
System.out.println(produtos);
Ao executar a aplicação, o terminal exibirá "Coca-Cola" e "Água".
[Coca-Cola, Água]
Ele não considera a ordem de inserção, pois primeiro inserimos "Água" e depois "Coca-Cola", mas não permitiu a repetição de "Água", mostrando apenas dois elementos.
Antes de inserir, há uma verificação para ver se o elemento já existe na lista, impedindo a inclusão novamente. É importante entender para que serve cada estrutura e qual utilizar em cada caso de aplicação.
Trabalhando com o Map
Por fim, vamos abordar a última estrutura, o Map. O Map utiliza a ideia de chave-valor, não permitindo valores duplicados. Temos um índice e um valor que compõem esse índice.
As principais implementações são:
HashMap;LinkedHashMap eTreeMap.
O objetivo é semelhante ao do Set. O HashMap é o mais rápido e não considera a ordem. O LinkedHashMap mantém a ordem de inserção, e o TreeMap é ordenado pela chave. No Map, o primeiro item é a chave e o segundo é o valor.
Ele possui operações diferentes dos anteriores, como:
Put;Get;Remove;ContainsKey e keySet.
A sintaxe é um pouco diferente, mas similar.
Vamos abordar um exemplo no qual criaremos um novo mapa para verificar. Já fizemos isso com pessoas funcionárias e produtos — agora, faremos com clientes.
Abaixo do último prinln(), criaremos um Map de Integer e String, onde Integer será o código do cliente (a chave) e String o nome (o valor). Para inicializar, usaremos um HashMap.
Também importaremos Map de java.util.
Quando trabalhamos com coleções, não usamos os tipos primitivos. Em vez disso, usamos os Wrappers, classes que envolvem os tipos primitivos e adicionam funcionalidades extras. Essas classes encapsulam os tipos básicos e permitem que eles sejam usados em contextos onde objetos são necessários, como em listas e outras estruturas de coleção.
public static void main(String[] args) {
Map<Integer, String> clientes = new HashMap<>();
}
Para inserir, utilizaremos clientes.put() em vez de add(). Adicionaremos três clientes: clientes.put(1, "Maria"), clientes.put(2, "Marcos") e clientes.put(3, "Ana").
clientes.put(1, "Maria");
clientes.put(2, "Marcos");
clientes.put(3, "Ana");
Para visualizar o mapa, usaremos System.out.println(clientes).
System.out.println(clientes);
Ao executar, ele exibirá "Maria", "Marcos" e "Ana", sem considerar a ordenação, mostrando a chave e o valor rapidamente.
{1=Maria, 2=Marcos, 3=Ana}
Se inserirmos uma chave repetida, como clientes.put(1, "Ana"), ele sobrescreverá o valor anterior.
clientes.put(1, "Maria");
clientes.put(2, "Marcos");
clientes.put(1, "Ana");
Ao visualizar, teremos 1=Ana e 2=Marcos. Mesmo com valores diferentes, a mesma chave considera o último valor inserido.
{1=Ana, 2=Marcos}
Para buscar uma posição específica, usamos get(). Se quisermos apenas o cliente com chave 1, usaremos clientes.get(1) no println(), que retornará "Ana", pois sobrescrevemos o valor.
System.out.println(clientes.get(1));
Ana
Vamos voltar a Ana para a chave 3, evitando confusões.
clientes.put(1, "Maria");
clientes.put(2, "Marcos");
clientes.put(3, "Ana");
Se quisermos a chave 2, retornará "Marcos".
System.out.println(clientes.get(2));
Marcos
Essa abordagem garante que buscamos pela chave, não pela ordem de inserção.
Um cenário para trabalhar com essa busca seria usar o CPF como chave e o nome como valor. Ao digitar o CPF, que é um identificador único, localizaríamos a pessoa correspondente, independentemente da ordem de armazenamento.
Conclusão
Trabalhar com coleções envolve chamar a coleção e, ao adicionar um ponto, visualizar todos os métodos disponíveis. É essencial consultar a documentação e exemplos, pois nenhum curso abrange todos os métodos. A curiosidade e a experimentação são fundamentais para explorar o universo de possibilidades com coleções em Java.
Esperamos que tenham gostado deste vídeo. No próximo, falaremos mais sobre como manipular essas informações utilizando Streams.