Tipos de Coleções e a Interface Collection no Java

No Java, arrays são úteis para armazenar conjuntos de dados, mas possuem uma limitação importante: tamanho fixo. Para superar isso, a linguagem fornece as coleções (collections), que oferecem estruturas mais flexíveis e eficientes.

Além de permitirem tamanhos dinâmicos, as coleções implementam algoritmos e estruturas de dados como pilhas (stack), filas (queue), árvores (tree) e outras.

Todas as classes de coleção estão no pacote java.util, que deve ser importado antes do uso.

Estrutura geral do sistema de coleções

Apesar da variedade de implementações, as coleções seguem uma hierarquia organizada e lógica. No núcleo estão as interfaces, que definem o comportamento básico:

• Collection – interface base para listas, conjuntos e filas.
• Queue – herda de Collection e representa filas.
• Deque – herda de Queue e representa filas de duas extremidades.
• List – herda de Collection e representa listas ordenadas.
• Set – herda de Collection e representa conjuntos de elementos únicos.
• SortedSet – herda de Set e mantém os elementos ordenados.
• NavigableSet – herda de SortedSet e adiciona navegação avançada.
• Map – armazena pares chave-valor; não herda de Collection.
• SortedMap – herda de Map e mantém chaves ordenadas.
• NavigableMap – herda de SortedMap e adiciona métodos para navegação.

Classes abstratas associadas

Algumas dessas interfaces têm implementações parciais em classes abstratas que servem como base para outras coleções:

• AbstractCollection – implementação genérica de Collection.
• AbstractList – herda de AbstractCollection e implementa List.
• AbstractSet – herda de AbstractCollection e implementa Set.
• AbstractQueue – herda de AbstractCollection e implementa Queue.
• AbstractSequentialList – herda de AbstractList para listas ligadas.
• AbstractMap – implementação genérica de Map.

Principais implementações

• ArrayList – lista baseada em array dinâmico.
• LinkedList – lista encadeada que também implementa Deque e Queue.
• ArrayDeque – fila dupla.
• HashSet – conjunto baseado em tabela de hash.
• LinkedHashSet – conjunto com ordem de inserção preservada.
• TreeSet – conjunto ordenado baseado em árvore.
• PriorityQueue – fila com prioridade.
• HashMap – mapa baseado em hash.
• LinkedHashMap – mapa baseado em hash com ordem de inserção preservada.
• TreeMap – mapa ordenado baseado em árvore.

Hierarquia completa simplificada

Iterable
└─ Collection
   ├─ List
   │  ├─ ArrayList
   │  └─ LinkedList  (também Deque e Queue)
   │
   ├─ Set
   │  ├─ HashSet
   │  ├─ LinkedHashSet
   │  └─ SortedSet
   │     └─ NavigableSet
   │        └─ TreeSet
   │
   └─ Queue
      ├─ PriorityQueue
      └─ Deque
         ├─ ArrayDeque
         └─ LinkedList  (também List)

Map
├─ HashMap
│  └─ LinkedHashMap
├─ SortedMap
│  └─ NavigableMap
│     └─ TreeMap
└─ Hashtable

A Interface Collection

Collection é a interface base para todas as coleções (exceto Map) e define o comportamento essencial:

public interface Collection<E> extends Iterable<E> {
    // definições de métodos
}

Por ser genérico (<E>) e herdar de Iterable<E>, qualquer coleção pode ser percorrida com for-each.

Métodos principais de Collection

• boolean add(E item) – adiciona um elemento.
• boolean addAll(Collection<? extends E> col) – adiciona todos os elementos de outra coleção.
• void clear() – remove todos os elementos.
• boolean contains(Object item) – verifica se a coleção contém o elemento.
• boolean isEmpty() – verifica se está vazia.
• Iterator<E> iterator() – retorna um iterador para percorrer a coleção.
• boolean remove(Object item) – remove o elemento especificado.
• boolean removeAll(Collection<?> col) – remove todos os elementos que também estão na coleção passada.
• boolean retainAll(Collection<?> col) – mantém apenas os elementos que também estão na coleção passada.
• int size() – retorna o número de elementos.
• Object[] toArray() – retorna um array com os elementos.

Exemplo simples:

Collection<String> nomes = new ArrayList<>();
nomes.add("Alice");
nomes.add("Bob");
System.out.println("Tamanho: " + nomes.size()); // Tamanho: 2

Resumo

• Coleções permitem armazenar e manipular dados de forma flexível, superando as limitações dos arrays.
• A interface Collection é a base para listas, conjuntos e filas; Map é separado.
• Classes abstratas facilitam a criação de coleções personalizadas.
• Implementações como ArrayList, HashSet e TreeMap oferecem estruturas prontas para uso.
• Collection define métodos comuns, garantindo consistência no uso de diferentes coleções.