Coleções

Programação Orientada a Objetos I

Prof. MSc. Leanderson André

leandersonandre@univille.br

Universidade da Região de Joinville

Coleções

Definição

Estruturas de dados utilizadas para armazenar e manipular grupos de elementos. O Java Collections Framework fornece interfaces e implementações para representar listas, conjuntos, filas e mapas, oferecendo operações como inserção, remoção, busca e iteração.

Java Collections Framework

Listas

Definição

Estruturas de dados que representam sequências de elementos, nas quais a ordem é preservada, elementos podem se repetir e cada elemento possui uma posição.

Listas

Listas representam computacionalmente o conceito matemático de sequência.

-5

Índice 0

Listas

A api de listas é definida na interface java.util.List.

Implementações de Listas

Implementação	Descrição
`ArrayList`	Armazena os elementos em um arranjo dinâmico, simulando um arranjo de tamanho variável.
`LinkedList`	Armazena os elementos em nós duplamente encadeados, facilitando o acesso ao primeiro e ao último elemento.

ArrayList

Prefira utilizar a interface List para declarar variáveis, parâmetros e atributos, deixando a implementação (ArrayList) como detalhe da instanciação.

import java.util.List;
import java.util.ArrayList;

// Criação de uma lista
List<Integer> lista = new ArrayList<>();

// Cria uma lista com capacidade inicial para 200 elementos.
List<Integer> lista2 = new ArrayList<Integer>(200);

// Inferência de tipos (variável do tipo ArrayList)
var lista3 = new ArrayList<Integer>();

Adicionar elementos na lista

O método add(elemento) adiciona o elemento ao final da lista.

List<Integer> lista = new ArrayList<>();

lista.add(1);
lista.add(2);
lista.add(3);

Adicionar elementos na lista

O método add(index,elemento) adiciona o elemento em uma posição específica da lista, deslocando os elementos seguintes.

List<Integer> lista = new ArrayList<>(List.of(1, 2, 3));

lista.add(1,99);

Obter um elemento pela posição

O método get(index) retorna o elemento na posição index.

List<Integer> lista = new ArrayList<>(List.of(1, 2, 3));

var elemento = lista.get(1);
System.out.println(elemento); // 2

Atualizar um elemento pela posição

O método set(index,elemento) substitui o elemento na posição index. O método retorna o elemento substituído.

List<Integer> lista = new ArrayList<>(List.of(1, 2, 3));

var substituido = lista.set(1,99);

System.out.println(substituido); // 2
System.out.println(lista.get(1)); // 99

Remover um elemento pela posição

O método remove(index) remove o elemento na posição index e retorna o elemento removido. Os elementos seguintes são deslocados uma posição à esquerda.

List<Integer> lista = new ArrayList<>(List.of(1, 2, 3));

var removido = lista.remove(1);

System.out.println(removido); // 2
System.out.println(lista.get(1)); // 3

Remoção por elemento

O método remove(elemento) remove a primeira ocorrência do elemento na lista e retorna true se a remoção for realizada. Os elementos seguintes são deslocados uma posição à esquerda.

List<Integer> lista = new ArrayList<>(List.of(1, 2, 3));

lista.remove(1);                  // remove pela posição
lista.remove(Integer.valueOf(1)); // remove pelo valor

Métodos úteis

var lista = new ArrayList<Integer>();

// Verifica se a lista contém o elemento
// Retorna true ou false
var contem = lista.contains(99);

// Retorna o índice da primeira ocorrência
// Retorna -1 caso não encontre o elemento
var indice = lista.indexOf(99);

Métodos úteis

// Retorna o índice da última ocorrência
var indice = lista.lastIndexOf(99);

// Retorna a quantidade de elementos
var tamanho = lista.size();

// Verifica se a lista está vazia
boolean vazio = lista.isEmpty();

// Remove todos os elementos da lista
lista.clear();

Percorrer a lista

A lista pode ser percorrida utilizando a estrutura de repetição for com índices, permitindo acessar cada elemento pela sua posição.

var lista = new ArrayList<Integer>();

for(var i = 0; i < lista.size(); i++){
  System.out.println(lista.get(i));
}

Percorrer a lista

A estrutura for-each permite percorrer todos os elementos da lista, do primeiro ao último, sem a necessidade de utilizar índices.

var lista = new ArrayList<Integer>();

for(var elemento : lista){
  System.out.println(elemento);
}

Acesso a posições inválidas

O acesso a uma posição inexistente da lista provoca a exceção IndexOutOfBoundsException.

Um índice válido deve estar entre 0 e size() - 1.

List<Integer> lista = new ArrayList<>(List.of(10, 20, 30));

// Índice negativo
lista.get(-1); // IndexOutOfBoundsException

// Índice igual ao tamanho da lista
lista.get(3);  // IndexOutOfBoundsException

// Índice maior que o tamanho da lista
lista.get(10); // IndexOutOfBoundsException

Conjuntos

Definição

Estruturas de dados que armazenam elementos distintos, sem estabelecer uma ordem entre eles.

Conjuntos

Conjuntos representam computacionalmente o conceito matemático de conjunto.

10 25 30 45 60

Conjuntos

A api de conjuntos é definida na interface java.util.Set.

Implementações de Conjuntos

Implementação	Descrição
`HashSet`	Armazena elementos utilizando uma tabela hash, sem garantir a ordem dos elementos.
`LinkedHashSet`	Armazena elementos utilizando uma tabela hash, preservando a ordem de inserção.
`TreeSet`	Armazena elementos em uma árvore, mantendo-os ordenados.

HashSet

Prefira utilizar a interface Hash para declarar variáveis, parâmetros e atributos, deixando a implementação (HashSet) como detalhe da instanciação.

import java.util.Set;
import java.util.HashSet;

// Criação de um conjunto
Set<Integer> conjunto = new HashSet<>();

// Inferência de tipos (variável do tipo HashSet)
var conjunto2 = new HashSet<Integer>();

Adicionar elementos no conjunto

O método add(elemento) adiciona o elemento no conjunto.

Set<Integer> conjunto = new HashSet<>();

conjunto.add(1);
conjunto.add(2);
conjunto.add(3);

Verificar se um elemento existe

O método contains(elemento) retorna true se o conjunto contiver o elemento informado e false caso contrário.

Set<Integer> conjunto = new HashSet<>(Set.of(1, 2, 3));

var resultado1 = conjunto.contains(1);  // true
var resultado2 = conjunto.contains(10); // false

Remoção por elemento

O método remove(elemento) remove o elemento do conjunto e retorna true se ele existir e for removido, ou false caso contrário.

Set<Integer> conjunto = new HashSet<>(Set.of(1, 2, 3));

var removido = lista.remove(1);

Métodos úteis


// Retorna a quantidade de elementos
var tamanho = conjunto.size();

// Verifica se a conjunto está vazia
boolean vazio = conjunto.isEmpty();

// Remove todos os elementos da conjunto
conjunto.clear();

Percorrer o conjunto

A estrutura for-each permite percorrer todos os elementos do conjunto, sem garantir uma ordem específica.

Set<Integer> conjunto = new HashSet<>(Set.of(1, 2, 3));

for(var elemento : conjunto){
  System.out.println(elemento);
}

Mapas

Definição

Os mapas são estruturas de dados que armazenam pares de elementos (chave, valor). Cada chave é única e utilizada para associar um determinado valor. Os valores podem se repetir.

Mapas

Conjuntos representam computacionalmente o conceito matemático de funções.

Chaves

1 2 3

⟶ ⟶ ⟶

Valores

Ana João Maria

Mapas

A api de mapas é definida na interface java.util.Map.

Implementações de Mapas

Implementação	Descrição
`HashMap`	Utiliza uma tabela hash, sem garantir a ordem dos elementos.
`LinkedHashMap`	Utiliza uma tabela hash, preservando a ordem de inserção.
`TreeMap`	Utiliza uma árvore, mantendo as chaves ordenadas.

HashMap

Prefira utilizar a interface Map para declarar variáveis, parâmetros e atributos, deixando a implementação (HashMap) como detalhe da instanciação.

import java.util.Map;
import java.util.HashMap;

// Criação de uma mapa
// Integer representa o tipo de dados da chave
// String representa o tipo de dados do valor
Map<Integer,String> mapa = new HashMap<>();

// Inferência de tipos (variável do tipo HashMap)
var mapa2 = new HashMap<Integer,String>();

Adicionar pares no mapa

O método put(chave,valor) adiciona o elemento no mapa.

Map<Integer,String> mapa = new HashMap<>();

mapa.put(1,"Argentina");
mapa.put(2,"Brasil");
mapa.put(3,"Chile");

Chaves		Valores
1	⟶	Argentina
2	⟶	Brasil
3	⟶	Chile

Adicionar pares no mapa

O mapa não permite duplicar a chave. Ao adicionar uma chave existente, seu valor é substituído.

Map<Integer,String> mapa = new HashMap<>();

mapa.put(1,"Argentina");
mapa.put(1,"Brasil");
mapa.put(1,"Chile");

Chaves		Valores
1	⟶	Chile

Obter o valor pela sua chave

O método get(chave) retorna o valor associado a chave. Caso a chave não exista no mapa, o método retorna null.

Map<Integer, String> mapa = new HashMap<>(
    Map.of(
        1, "Argentina",
        2, "Brasil",
        3, "Chile"
    )
);

var valor = mapa.get(2); // Brasil
var valor2 = mapa.get(99); // null

Obter o valor pela sua chave

O método getOrDefault(chave,default) retorna o valor associado à chave. Caso ela não exista no mapa, retorna o valor padrão informado.

Map<Integer, String> mapa = new HashMap<>(
    Map.of(
        1, "Argentina",
        2, "Brasil",
        3, "Chile"
    )
);

var valor = mapa.getOrDefault(99,"País desconhecido"); 
// País desconhecido
System.out.println(valor);

Verificar se existe uma chave

O método containsKey(chave) verifica se a chave existe no mapa. Retorna true caso existir. Caso contrário retorna false.

Map<Integer, String> mapa = new HashMap<>(
    Map.of(
        1, "Argentina",
        2, "Brasil",
        3, "Chile"
    )
);

var valor1 = mapa.containsKey(1); // true
var valor2 = mapa.containsKey(2); // false

Verificar se existe um valor

O método containsValue(valor) verifica se o valor existe no mapa. Retorna true caso existir. Caso contrário retorna false.

Map<Integer, String> mapa = new HashMap<>(
    Map.of(
        1, "Argentina",
        2, "Brasil",
        3, "Chile"
    )
);

var valor1 = mapa.containsValue("Brasil");    // true
var valor2 = mapa.containsValue("Dinamarca"); // false

Remover uma chave

O método remove(chave) remove a chave do mapa e retorna o valor associado.

Map<Integer, String> mapa = new HashMap<>(
    Map.of(
        1, "Argentina",
        2, "Brasil",
        3, "Chile"
    )
);

var valor1 = mapa.remove(2);    // Brasil

Métodos úteis


// Retorna a quantidade de elementos
var tamanho = mapa.size();

// Verifica se a conjunto está vazia
boolean vazio = mapa.isEmpty();

// Remove todos os elementos do mapa
mapa.clear();

Percorrer o mapa

A estrutura for-each permite percorrer todos os pares(chave,valor) do mapa, sem garantir uma ordem específica.

Map<Integer, String> mapa = new HashMap<>(
    Map.of(
        1, "Argentina",
        2, "Brasil",
        3, "Chile"
    )
);

// Percorre os pares
for(var par : mapa.entrySet()){
  System.out.println(par.getKey());
  System.out.println(par.getValue());
}

Percorrer o mapa


// Percorre as chaves
for(var chave : mapa.keySet()){
  System.out.println(chave);
}

// Percorre os valores
for(var valor : mapa.values()){
  System.out.println(valor);
}

Comparação entre Lista, Conjunto e Mapa

Característica	List	Set	Map
Elementos repetidos	Sim	Não	Chaves não
Acesso por índice	Sim	Não	Não
Associação chave-valor	Não	Não	Sim
Ordem dos elementos	Preservada	Depende da implementação	Depende da implementação

Prof. MSc. Leanderson André

leandersonandre@univille.br

Universidade da Região de Joinville