Interfaces Collection, List, Set, Map: hierarquia

1. O que é a interface Collection

Em Java, uma interface é como um contrato: se uma classe implementa a interface, ela é obrigada a fornecer a implementação de todos os seus métodos. A própria interface não armazena estado e não contém código (quase: a partir do Java 8 são possíveis métodos default, mas aqui o importante é a ideia básica).

Collection é a interface base para a maioria das coleções em Java. Ela define o que uma coleção sabe fazer: adicionar elementos, remover, obter o tamanho, verificar a presença de elementos etc.

public interface Collection<E> extends Iterable<E> {
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    boolean add(E e);
    boolean remove(Object o);
    void clear();
    Iterator<E> iterator();
    // ... e mais um monte de métodos úteis
}

Métodos principais:

• add(E e) — adicionar elemento.
• remove(Object o) — remover elemento.
• size() — obter a quantidade de elementos.
• isEmpty() — verificar se a coleção está vazia.
• contains(Object o) — verificar a presença de um elemento.
• clear() — limpar a coleção.
• iterator() — obter um iterador para percorrer.

Por que Map não herda de Collection?

Map ocupa um lugar à parte entre as coleções. Porque Map é um conjunto de pares chave → valor, e não apenas um conjunto de elementos. Ele tem um contrato diferente e outro conjunto de métodos. Por exemplo, em Map não existe o método add, porque a adição é feita via put(key, value), e não faz sentido verificar a presença de um valor sem saber a chave.

2. Hierarquia das coleções

A “árvore” mental das interfaces principais fica assim:

                Iterable
                   |
               Collection
               /    |    \
            List   Set   Queue
                          |
                        Deque

• Iterable — a interface mais básica: tudo o que pode ser percorrido no laço for-each.
• Collection — estende Iterable, adiciona operações para trabalhar com uma coleção de elementos.
• Três ramos principais:
  • List — lista ordenada, permite duplicatas.
  • Set — conjunto de elementos únicos, a ordem depende da implementação.
  • Queue — fila (geralmente FIFO); subtipo — Deque (fila dupla).

E o Map vive separado:

                Map
               /   \
         HashMap  TreeMap

Visualização da hierarquia (diagrama)

                            +--------------------+
                            |     Iterable<E>    |
                            +--------------------+
                                     |
                            +--------------------+
                            |   Collection<E>    |
                            +--------------------+
                          /     |         \
                +--------+   +-------+   +-------+
                |  List  |   |  Set |   | Queue |
                +--------+   +-------+   +-------+
                                     |
                                  +------+
                                  |Deque |
                                  +------+

        +--------------------+
        |      Map<K,V>      |
        +--------------------+

3. List: coleção ordenada com duplicatas

List é uma coleção em que:

• A ordem dos elementos é importante (primeiro, segundo, terceiro…).
• Duplicatas são permitidas.
• É possível obter um elemento pelo índice (list.get(2)), substituir e inserir em qualquer posição.

Exemplos de implementações: ArrayList — acesso rápido por índice; LinkedList — bom para inserções/remoções frequentes no meio.

import java.util.*;

List<String> shoppingList = new ArrayList<>();
shoppingList.add("Leite");
shoppingList.add("Pão");
shoppingList.add("Queijo");
shoppingList.add("Pão"); // Duplicatas são permitidas!

System.out.println(shoppingList.get(1)); // "Pão"

Métodos típicos de List:

• add(E e), add(int index, E e)
• get(int index), set(int index, E e)
• remove(int index), remove(Object o)
• indexOf(Object o), lastIndexOf(Object o)

4. Set: conjunto de elementos únicos

Set é uma coleção em que:

• Cada elemento é único (sem duplicatas).
• A ordem de armazenamento não é garantida em HashSet, pode haver ordenação em TreeSet ou ordem de inserção em LinkedHashSet.

Exemplos de implementações: HashSet, TreeSet, LinkedHashSet.

import java.util.*;

Set<String> uniqueNames = new HashSet<>();
uniqueNames.add("Anya");
uniqueNames.add("Boris");
uniqueNames.add("Anya"); // Não será adicionado — já existe!

System.out.println(uniqueNames.contains("Anya")); // true
System.out.println(uniqueNames.size()); // 2

Métodos típicos de Set:

• add(E e), remove(Object o)
• contains(Object o)
• size(), isEmpty()

5. Map: coleção de pares chave-valor

Map é uma coleção em que:

• Cada elemento é um par chave → valor.
• As chaves são únicas, os valores podem se repetir.
• Acesso rápido pela chave.

Exemplos de implementações: HashMap, TreeMap, LinkedHashMap.

import java.util.*;

Map<String, String> phoneBook = new HashMap<>();
phoneBook.put("Anya", "+19991112233");
phoneBook.put("Boris", "+19994445566");
phoneBook.put("Anya", "+19990001122"); // Vai sobrescrever o número de Anya!

System.out.println(phoneBook.get("Anya")); // "+19990001122"
System.out.println(phoneBook.containsKey("Boris")); // true

Métodos típicos de Map:

• put(K key, V value), get(K key)
• remove(K key)
• containsKey(K key), containsValue(V value)
• keySet(), values(), entrySet()

6. Visualização da hierarquia: tudo em uma imagem

Uma pequena tabela resumida:

List

ArrayList, LinkedList

Set

HashSet, TreeSet

Map

HashMap, TreeMap

Hierarquia no diagrama:

                Collection
                /    |    \
             List   Set   Queue
                            |
                          Deque

                Map (separado)

7. Quando usar qual interface

List

• Quando a ordem dos elementos é importante (por exemplo, o histórico de ações do usuário).
• Quando são necessárias duplicatas (por exemplo, itens de um pedido).
• Quando é preciso acesso/substituição rápidos por índice.

Set

• Quando é necessária unicidade (e-mail, logins, id).
• Quando a ordem não importa, ou ao contrário — é preciso um conjunto automaticamente ordenado (TreeSet).

Map

• Quando é preciso associar chaves e valores (id → objeto, login → perfil).
• Quando é necessária busca rápida pela chave.
• Quando as chaves devem ser únicas e os valores — não.

8. Erros comuns ao trabalhar com a hierarquia de coleções

Erro nº 1: usar a interface errada na declaração da variável. Se você escreve ArrayList<String> list = new ArrayList<>();, você se prende rigidamente à implementação. Prefira List<String> list = new ArrayList<>(); — assim fica mais fácil trocar a implementação.

Erro nº 2: tentar adicionar duplicatas a um Set e esperar que apareçam. Isso não é bug, é característica: Set, por definição, não armazena duplicatas. A inserção repetida é ignorada.

Erro nº 3: usar Map como uma coleção comum. Map não é lista nem conjunto. Para percorrer, use keySet(), values() ou entrySet().

Erro nº 4: esperar ordenação em HashSet ou HashMap. HashSet e HashMap não garantem ordem. Se ela for importante — use LinkedHashSet ou LinkedHashMap.

Erro nº 5: usar List para elementos únicos. Se precisar de unicidade — use Set. List não impede duplicatas.