Visão Geral do Framework de Coleções

Coleções são ferramentas centrais para armazenar e manipular dados. Esta lição cobre a estrutura geral do Java Collection Framework.

Por que Coleções São Necessárias

Arrays têm limitações de tamanho fixo; coleções podem crescer dinamicamente.

Arrays vs Coleções

Característica	Array	Coleção
Tamanho	Fixo	Dinâmico
Tipo	Primitivos/Objetos	Apenas objetos
Métodos	Nenhum	Métodos ricos
Generics	Não suportado	Suportado

Arquitetura do Collection Framework

TEXT

Coleção (interface)
├── Lista (interface) — Ordenada, permite duplicatas
│   ├── ArrayList (implementação)
│   ├── LinkedList (implementação)
│   └── Vector (implementação)
├── Set (interface) — Não ordenado, sem duplicatas
│   ├── HashSet (implementação)
│   ├── TreeSet (implementação)
│   └── LinkedHashSet (implementação)
└── Queue (interface) — Fila
    ├── LinkedList (implementação)
    └── PriorityQueue (implementação)

Map (interface) — Pares chave-valor
├── HashMap (implementação)
├── TreeMap (implementação)
├── LinkedHashMap (implementação)
└── Hashtable (implementação)

Interface Collection

Collection é a interface pai para todas as coleções de valor único.

Métodos Comuns

Método	Descrição	Tipo de Retorno
`add(E e)`	Adicionar elemento	`boolean`
`remove(Object o)`	Remover elemento	`boolean`
`contains(Object o)`	Contém elemento	`boolean`
`isEmpty()`	Está vazio	`boolean`
`size()`	Contagem de elementos	`int`
`clear()`	Limpar tudo	`void`
`toArray()`	Converter para array	`Object[]`

Exemplo: Operações Básicas de Coleção

JAVA

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();
        
        // Adicionar elementos
        collection.add("Alice");
        collection.add("Bob");
        collection.add("Charlie");
        System.out.println("Coleção: " + collection);  // [Alice, Bob, Charlie]
        
        // Verificar
        System.out.println("Contém Alice: " + collection.contains("Alice"));  // true
        System.out.println("Tamanho: " + collection.size());  // 3
        System.out.println("Está vazio: " + collection.isEmpty());  // false
        
        // Remover
        collection.remove("Bob");
        System.out.println("Após remover: " + collection);  // [Alice, Charlie]
        
        // Converter para array
        Object[] array = collection.toArray();
        for (Object obj : array) {
            System.out.println(obj);
        }
        
        // Limpar
        collection.clear();
        System.out.println("Após limpar, tamanho: " + collection.size());  // 0
    }
}

▶ Experimente

Iterable e Iterator

Interface Iterable

Classes que implementam Iterable podem ser percorridas com for-each.

Interface Iterator

Iterator é usado para percorrer coleções.

Método	Descrição
`hasNext()`	Tem próximo elemento
`next()`	Obter próximo elemento
`remove()`	Remover elemento atual

Exemplo: Usando Iterator

JAVA

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

public class IteratorDemo {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        
        // Método 1: for-each
        for (String name : names) {
            System.out.println(name);
        }
        
        // Método 2: Iterator
        Iterator<String> it = names.iterator();
        while (it.hasNext()) {
            String name = it.next();
            System.out.println(name);
        }
        
        // Método 3: Remover com Iterator
        Iterator<String> it2 = names.iterator();
        while (it2.hasNext()) {
            String name = it2.next();
            if (name.startsWith("B")) {
                it2.remove();  // Remoção segura
            }
        }
        System.out.println("Após remover: " + names);  // [Alice, Charlie]
    }
}

▶ Experimente

⚠️ Nota: Ao remover elementos durante a travessia, use o método remove do Iterator, não o método remove da coleção, caso contrário ConcurrentModificationException será lançado.

Interface List

Coleção ordenada, permite duplicatas.

Características

Característica	Descrição
Ordenada	Elementos na ordem de inserção
Permite duplicatas	Pode ter elementos iguais
Acesso por índice	Acessar elementos por índice

Métodos Comuns

Método	Descrição
`get(int index)`	Obter elemento no índice
`set(int index, E e)`	Definir elemento no índice
`add(int index, E e)`	Inserir na posição
`remove(int index)`	Remover elemento no índice
`indexOf(Object o)`	Encontrar índice do elemento
`subList(int from, int to)`	Obter sublista

Interface Set

Coleção não ordenada, sem duplicatas.

Características

Característica	Descrição
Não ordenada	Sem ordem fixa
Sem duplicatas	Desduplicação automática
Sem índice	Não pode acessar por índice

Interface Map

Coleção de pares chave-valor, chaves não podem ser duplicadas.

Características

Característica	Descrição
Pares chave-valor	Cada elemento tem chave e valor
Chaves únicas	Chaves únicas, valores podem se repetir
Não ordenada	HashMap não é ordenado

Métodos Comuns

Método	Descrição
`put(K k, V v)`	Adicionar par chave-valor
`get(K k)`	Obter valor pela chave
`remove(K k)`	Remover par chave-valor
`containsKey(K k)`	Contém chave
`keySet()`	Todas as chaves
`values()`	Todos os valores
`entrySet()`	Todos os pares chave-valor

Guia de Seleção de Coleção

Necessidade	Escolha
Ordenada, permite duplicatas	`ArrayList`
Não ordenada, sem duplicatas	`HashSet`
Ordenada, sem duplicatas	`LinkedHashSet`
Ordenada por valor, sem duplicatas	`TreeSet`
Pares chave-valor	`HashMap`
Pares chave-valor ordenados	`TreeMap`

❓ Perguntas Frequentes

P: Como escolher entre ArrayList e LinkedList? R: Use ArrayList para consultas frequentes. Use LinkedList para adições/remoções frequentes. Geralmente use ArrayList.

P: Como funciona a desduplicação do HashSet? R: Primeiro compara hashCode, depois compara equals. Ambos devem corresponder para ser considerado duplicado.

P: Qual é a diferença entre HashMap e Hashtable? R: HashMap não é thread-safe, mas mais rápido. Hashtable é thread-safe, mas mais lento. HashMap é recomendado.

📖 Resumo

O Collection Framework tem duas hierarquias principais: Collection e Map
List é ordenada com duplicatas, Set é não ordenado sem duplicatas, Map é pares chave-valor
Iterator é usado para percorrer coleções
Escolha o tipo de coleção certo com base nas necessidades

📝 Exercícios

Operações com coleção: Crie um ArrayList, adicione 10 elementos, percorra e remova números pares
Desduplicação: Remova elementos duplicados de um array (use HashSet)
Prática com Map: Conte a ocorrência de cada caractere em uma string

Próxima Lição

Na próxima lição, aprenderemos sobre List e ArrayList — uso detalhado de List.