A interface Coleção define as operações comuns para listas, vetores, pilhas, filas, filas de prioridade e conjuntos.

O Java Collections Framework oferece suporte a dois tipos de contêineres:

• Um para armazenar uma coleção de elementos é simplesmente chamado de coleção.
• O outro, para armazenar pares chave/valor, é chamado de mapa.

Mapas são estruturas de dados eficientes para pesquisar rapidamente um elemento usando uma chave. Aqui estão as seguintes coleções.

• Sets armazenam um grupo de elementos não duplicados.
• Listass armazenam uma coleção ordenada de elementos.
• Stacks armazenam objetos que são processados ​​da maneira último a entrar, primeiro a sair.
• Filass armazenam objetos que são processados ​​do modo primeiro a entrar, primeiro a sair.
• PriorityQueues armazenam objetos que são processados ​​na ordem de suas prioridades.

Os recursos comuns dessas coleções são definidos nas interfaces e as implementações são fornecidas em classes concretas, conforme mostrado na figura abaixo.

Todas as interfaces e classes definidas no Java Collections Framework são agrupadas no pacote java.util.

O design do Java Collections Framework é um excelente exemplo de uso de interfaces, classes abstratas e classes concretas. As interfaces definem a estrutura. As classes abstratas fornecem implementação parcial. As classes concretas implementam as interfaces com estruturas de dados concretas. Fornecer uma classe abstrata que implemente parcialmente uma interface torna conveniente para o usuário escrever o código. O usuário pode simplesmente definir uma classe concreta que estenda a classe abstrata em vez de implementar todos os métodos na interface. As classes abstratas como AbstractCollection são fornecidas por conveniência. Por esse motivo, são chamadas de classes abstratas de conveniência.

A interface Collection é a interface raiz para manipular uma coleção de objetos. Seus métodos públicos estão listados na figura abaixo. A classe AbstractCollection fornece implementação parcial para a interface Collection. Ele implementa todos os métodos em Collection, exceto os métodos add, size e iterator. Eles são implementados em subclasses concretas apropriadas.

A interface Collection fornece as operações básicas para adicionar e remover elementos em uma coleção. O método add adiciona um elemento à coleção. O método addAll adiciona todos os elementos da coleção especificada a esta coleção. O método remove remove um elemento da coleção. O método removeAll remove os elementos desta coleção que estão presentes na coleção especificada. O método retainAll retém os elementos desta coleção que também estão presentes na coleção especificada. Todos esses métodos retornam booleano. O valor de retorno é true se a coleção for alterada como resultado da execução do método. O método clear() simplesmente remove todos os elementos da coleção.

Os métodos addAll, removeAll e retainAll são semelhantes às operações de união, diferença e interseção de conjuntos.

A interface Coleção fornece diversas operações de consulta. O método size retorna o número de elementos da coleção. O método contains verifica se a coleção contém o elemento especificado. O método containsAll verifica se a coleção contém todos os elementos da coleção especificada. O método isEmpty retorna true se a coleção estiver vazia.

A interface Collection fornece o método toArray(), que retorna uma representação de array para a coleção.

Alguns dos métodos na interface Collection não podem ser implementados na subclasse concreta. Nesse caso, o método lançaria java.lang.UnsupportedOperationException, uma subclasse de RuntimeException. Este é um bom design que você pode usar em seu projeto. Se um método não tiver significado na subclasse, você pode implementá-lo da seguinte maneira:

public void someMethod() {
lança nova UnsupportedOperationException
("Método não suportado");
}

O código abaixo dá um exemplo de uso dos métodos definidos na interface Collection.

package demo;
import java.util.*;

public class TestCollection {

    public static void main(String[] args) {
        ArrayList collection1 = new ArrayList();
        collection1.add("New York");
        collection1.add("Atlanta");
        collection1.add("Dallas");
        collection1.add("Madison");

        System.out.println("A list of cities in collection1:");
        System.out.println(collection1);

        System.out.println("\nIs Dallas in collection1? "   collection1.contains("Dallas"));

        collection1.remove("Dallas");
        System.out.println("\n"   collection1.size()   " cities are in collection1 now");

        Collection collection2 = new ArrayList();
        collection2.add("Seattle");
        collection2.add("Portland");
        collection2.add("Los Angeles");
        collection2.add("Atlanta");

        System.out.println("\nA list of cities in collection2:");
        System.out.println(collection2);

        ArrayList c1 = (ArrayList)(collection1.clone());
        c1.addAll(collection2);
        System.out.println("\nCities in collection1 or collection2: ");
        System.out.println(c1);

        c1 = (ArrayList)(collection1.clone());
        c1.retainAll(collection2);
        System.out.print("\nCities in collection1 and collection2: ");
        System.out.println(c1);

        c1 = (ArrayList)(collection1.clone());
        c1.removeAll(collection2);
        System.out.print("\nCities in collection1, but not in 2: ");
        System.out.println(c1);
    }

}

Uma lista de cidades na coleção1:
[Nova York, Atlanta, Dallas, Madison]
Dallas está na coleção1? verdadeiro
3 cidades estão na coleção1 agora
Uma lista de cidades na coleção2:
[Seattle, Portland, Los Angeles, Atlanta]
Cidades na coleção1 ou coleção2:
[Nova York, Atlanta, Madison, Seattle, Portland, Los Angeles, Atlanta]
Cidades na coleção1 e coleção2: [Atlanta]
Cidades na coleção 1, mas não na coleção 2: [Nova York, Madison]

O programa cria um objeto de coleção concreto usando ArrayList (linha 7) e invoca o método contains da interface Collection (linha 16), método remove (linha 18), método size (linha 19), método addAll (linha 31), método retainAll (linha 36) e Método removeAll (linha 41).

Para este exemplo, usamos ArrayList. Você pode usar qualquer classe concreta de Collection, como HashSet, LinkedList, Vector e Stack para substituir ArrayList para testar esses métodos definidos na interface Collection.

O programa cria uma cópia de uma lista de array (linhas 30, 35, 40). O objetivo disso é manter a lista de array original intacta e usar sua cópia para executar as operações addAll, retainAll e removeAll.

Todas as classes concretas no Java Collections Framework implementam as interfaces java.lang.Cloneable e java.io.Serializable, exceto java.util.PriorityQueue não implementa a interface Cloneable. Assim, todas as instâncias de Cloneable, exceto as filas de prioridade, podem ser clonadas e todas as instâncias de Cloneable podem ser serializadas.