Tipos de conjuntos Java

Existem quatro interfaces de conjuntos em java:

0 - Collection
1 - List
2 - Queue
3 - Set
4 - Map

=======================================================
0 - Collection

- Interface da qual as interfaces List, Queue e Set extendem.
- Possui métodos, tais como: add(), remove(), contains(), size() e iterator().

=======================================================
Criação dos conjuntos:

- A forma de criação básica mostrada abaixo é igual para todos os conjuntos.

- Como criar um ArrayList em Java 1.4?
  Ex.: ArrayList list = new ArrayList();    // Com tamanho defaut 10, podem ser inseridos qualquer classe que extenda de Object.
  Ex.: ArrayList list = new ArrayList(20);    // Com tamanho definido 20.          
- Em java 5, é possível e recomendado definir o tipo do conjuto (Genéricos).
  Ex.: ArrayList<Integer> list = new ArrayList<Integer>(5);   // ArrayList de tamanho 5 e objetos do tipo Integer
  Ex.: TreeMap<String, Integer> map = new TreeMap<String, Integer>(20); // TreeMap de tamanho 20, chave do tipo String e objetos do tipo Integer 
  
=======================================================
1 - List

- Extende de Collection
- É ordenado por índice, mas não é classificado.
- Ordem dos elementos obedece a inserção. Ou o índice que é passado na inserção.
- Para classificar (colocar na ordem) um List é necessário utilizar o método utilitário abaixo, lembrando que o tipo de objeto usado na lista deve implementar a interface Comparable ou Comparator.
  Ex.: Collections.sort(list); ou Collections.sort(list, comparator)
- A estrutura interna é baseada em um Array.
- O tamanho padrão é 10, porém pode ser definido na criação outro valor. 
- O tamanho é expandido automaticamente quando necessário. 
- É possível inserir um elemento no meio da lista.
  Ex.: list.add(2, "elemento");
- É possível buscar um elemento no meio da lista pelo índice.
  Ex.: list.get(2);
- É possível descobrir a posição (índice) de um item na lista.
  Ex.: list.indexOf("elemento");

Subtipos List:

1.1 - ArrayList

- Implementa a interface RandomAccess (interface que informa o suporte a acesso aleatório rápido).
- Mais lento que LinkedList em inserções e exclusões.
- Proporciona iteração e acesso aleatório com rapidez. Portanto preferível que LinkedList nessas situações.

1.2 - Vector 

- Implementa a interface RandomAccess (interface que informa o suporte a acesso aleatório rápido).
- Métodos sincronizados, torna essa lista mais lenta que as outras, somente usar Vector se precisar dessa característica, devido a um ambiente multi threaded.

1.3 - LinkedList

- Mais lento do que ArrayList no que diz respeito à iteração.
- Mais rápido para inserções e exclusões rápidas.
- Ideal para implementar filas ou pilhas, devido a capacidade de adicionar e remover elementos no início ou final da lista.
  Ex.: list.addFisrt();
  Ex.: list.addLast();
- Acessar os elementos no início ou final.
  Ex.: list.getFisrt();
  Ex.: list. getLast();
- A partir do Java 5, passou a implementar a interface Queue, portanto oferece os métodos de filas (descritos na seção 2 - Queue abaixo):
  Ex.: list.peek();
  Ex.: list.poll();
  Ex.: list.offer();


=======================================================
2 - Queue

- Extende de Collection
- A partir do Java 5, filas básicas podem ser criadas com LinkedList, sem ordenamento.

Subtipos Queue:

2.1 - LinkedList

- Igual ao 1.3.

2.2 - PriorityQueue

- Fila tipo "priority in, priority out" com ordenamento.
- Ordenado pela ordem natural (string, ordem alfabetica). Ou de acordo com um Comparator ou Comparable. Sempre classificado.
- Não é possível usar PriorityQueue com objetos que não tenham como ser classificados (colocados em ordem). Exceção é lançada em runtime ClassCastException para Comparable.
- Para ordenar com Comparable basta ter implementado a interface.
- Para ordenar com Comparator, utilize a seguinte criação:
  Ex.: PriorityQueue<Integer>  list = new PriorityQueue<Integer> (20, comparator);
  Ex.: list.peek();   // pega o primeiro item e não o tira da fila
  Ex.: list.poll();   // pega o primeiro item e o tira da fila
  Ex.: list.offer();  // inseri itens na fila

=======================================================
3 - Set 

- Extende de Collection
- Não aceitam duplicatas (elementos repetidos), verificados usando os métodos hashCode() e equals().
- Não implementar hashCode() e equals() no objeto inserido na lista anula a funcionalidade de retirar duplicatas. 
- Não é possível indexar os elementos por índices numéricos, como em uma List. 

Subtipos Set:

3.1 - HashSet

- Não tem como definir a ordenação dos objetos. Não classificavel.
    
3.2 - LinkedHashSet

- Itera por ordem de inserção. Não classificavel.
- Ideal em caso de necessidade de ordem na iteração.
- Mais lenta que HashSet na inserção, pois registra o elemento posterior e anterior. 

3.3 - TreeSet

- Ordenado de forma natural ou de ordem predeterminada (Comparator ou Comparable). Sempre classificado.
- Não é possível usar TreeSet com objetos que não tenham como ser classificados (colocados em ordem). Exceção é lançada em runtime ClassCastException para Comparable.           

=======================================================
4 - Map

- Não extende de Collection.
- Indexado por chave (key) de qualquer tipo de objeto e não apenas por números como List.
- A chave não pode ser duplicada, os valores sim. A duplicidade da chave é verificada pelo método equals().
- Os métodos hashCode() e equals() devem ser sobrescritos, mas não obrigatoriamente. 

Subtipos de Map:

4.1 - HashMap

- Não é ordenado. Não é classificado. Nenhuma ordem é garantida.
- Permite inserção de chave nula (apenas um item pode ter a chave nula) e valores nulos (múltiplos itens com valor nulo).

4.2 - HashTable

- Não é ordenado. Não é classificado. Nenhuma ordem é garantida.
- Métodos são sincronizados, operações mais lentas.
- HashTable não permite valores nulos nem para chave, nem para o valor. 

4.3 - LinkedHashMap

- Mantem a ordem ordem de inserção ou do último acesso. Não é classificado.
- Mais rápido para iterações do que LinkedHashSet.
- Mais lento para para inserções e remoções do que LinkedHashSet.
- Criado com o contrutor sem parametros. A ordem é de inserção da chave(key) independente se o valor for alterado.
- É possível usar um construtor sobrecarregado que ordena pela último acesso. O último a ser acessado fica no fim da lista.
  
4.4 - TreeMap

- Implementar a interface Comparable ou Comparator, para que a lista saia ordenada. Ordenado e sempre classificado.
- Não é possível usar TreeMap com objetos que não tenham como ser classificados (colocados em ordem). Exceção é lançada em runtime ClassCastException para Comparable.