Fale sobre a hierarquia de coleções em Java.

A hierarquia de coleções em Java é construída em torno de duas interfaces raiz: Collection e Map. Ela é definida no pacote java.util.

• Collection<E>: Interface raiz para a maioria das coleções. Representa um grupo de elementos. Não garante ordem nem unicidade dos elementos.
  • List<E>: Coleção ordenada (sequência). Os elementos têm um índice definido. Podem conter duplicados.
    • ArrayList<E>: Implementação baseada em array. Acesso aleatório rápido, inserções/exclusões lentas no meio.
    • LinkedList<E>: Implementação baseada em lista ligada. Acesso lento, inserções/exclusões rápidas no início/fim.
    • Vector<E>: Classe sincronizada obsoleta. Semelhante ao ArrayList, mas segura para threads (e menos eficiente).
    • Stack<E>: Classe obsoleta que estende Vector, implementa comportamento de pilha (LIFO).
  • Set<E>: Coleção que contém elementos únicos.
    • HashSet<E>: Implementação baseada em tabela hash. Não ordenada. Operações rápidas add, remove, contains.
    • LinkedHashSet<E>: Mantém a ordem de inserção.
    • SortedSet<E>: Conjunto ordenado em ordem crescente.
      • TreeSet<E>: Implementação baseada em árvore vermelho-preto. Garante ordenação.
  • Queue<E>: Coleção projetada para armazenar elementos antes do processamento, muitas vezes em ordem FIFO (First-In, First-Out).
    • PriorityQueue<E>: Implementação de fila de prioridade. Os elementos são extraídos de acordo com sua prioridade.
    • Deque<E>: (Fila de duas extremidades) Fila bidirecional. Suporta inserções e remoções de ambos os extremos.
      • ArrayDeque<E>: Implementação de Deque baseada em array dinâmico. Mais rápido que LinkedList para uso como pilha ou fila.
• Map<K, V>: Objeto que mapeia chaves para valores. As chaves são únicas, os valores podem se repetir.
  • HashMap<K, V>: Implementação baseada em tabela hash. Não ordenada. Operações rápidas put, get, remove.
  • LinkedHashMap<K, V>: Mantém a ordem de inserção ou acesso.
  • SortedMap<K, V>: Mapa ordenado por chaves.
    • TreeMap<K, V>: Implementação baseada em árvore vermelho-preto. Garante ordenação por chaves.
  • Hashtable<K, V>: Classe sincronizada obsoleta. Semelhante ao HashMap, mas segura para threads (e menos eficiente).

Interfaces principais:

Interface	Descrição	Ordem	Unicidade	Duplicados de valores
Collection	Grupo de elementos	+/-	+/-	Sim
List	Coleção ordenada	Sim	Não	Sim
Set	Coleção de elementos únicos	+/-	Sim	Não
Queue	Coleção para processamento (FIFO)	Sim	Não	Sim
Deque	Fila bidirecional	Sim	Não	Sim
Map	Mapa chave-valor	+/-	Por chave	Sim
SortedSet	Conjunto ordenado	Sim	Sim	Não
SortedMap	Mapa ordenado por chaves	Sim	Por chave	Sim

Exemplo de uso:

// Exemplo de uso de ArrayList
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
System.out.println(names.get(0)); // Alice

// Exemplo de uso de HashSet
Set<Integer> uniqueNumbers = new HashSet<>();
uniqueNumbers.add(1);
uniqueNumbers.add(2);
uniqueNumbers.add(1); // Duplicado ignorado
System.out.println(uniqueNumbers.size()); // 2

// Exemplo de uso de HashMap
Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 30);
ages.put("Bob", 25);
System.out.println(ages.get("Alice")); // 30