Collection

Olá a todos que acompanham ao blog, hoje pretendo escrever sobre o maior assunto que é cobrado na prova de certificação programador Java ou SCJP. Na minha opinião, é o maior assunto, mas não é o mais complicado, isso fica por conta de um assunto chamado: Thread (falarei disso em outra postagem). Como o assunto é grande, não pretendo abordar detalhadamente tudo e sim, escrever sobre alguns tópicos importantes.
É fundamental saber que a API de conjuntos é formada por Interfaces(List,Set e etc) e Classes(ArrayList, TreeSet e etc).
Principais INTERFACES que é preciso saber para a prova( e para a vida real): Collection, List, Set, Map, Queue, SortedMap e SortedSet. Classes concretas que é preciso saber: HashMap, Hashtable, TreeMap, LinkedHashMap, HashSet, LinkedHashSet, TreeSet, ArrayList, Vector, LinkedList, PriorityQueue, Collections e Arrays.
Os conjuntos são divididos em quatro tipos: Listas, Conjuntos, Mapas e Filas. E ainda tem mais quatro características: Classificada, não Classificada, Ordenada e não Ordenada. Obs: um conjunto pode ser não-classificado e não-ordenado, ordenado e não-classificado ou ordenado e classificado, mas nunca pode ser classificado e não-ordenado( porque classificação é um tipo de ordenação).
Abordando as Interfaces
LIST: é o conjunto que o índice tem relevância, é o único que tem o método indexOf(). Classes Concretas:

• ArrayList: é como uma array que pode crescer.

• Vector: é semelhante ao arraylist, a diferença é que tem os seus métodos sincronizados em relação a thread.

• LinkedList: tem os seus elementos duplamente encadeados entre si. Essa classe também implementa a interface Queue, entao também tem os métodos: peek, poll e offer.

SET:da relevância a exclusividade, assim não permite elementos duplicados. O método equals() determinará se os elementos são iguais.

• HashSet: usa o código hashing do objeto para fazer a inserção.

• LinkedHashSet: é uma versão ordenada de HashSet, mandando uma lista de encadeamento duplo para os elementos.

• TreeSet: garante que os elementos fiquem em sequencia ascendente.

MAP: identificadores exclusivos é que são relevantes. Uma classes exclusiva (o identificador) é mapeada para um valor.

• HashMap: é um conjunto não-classificado e não-ordenado; e a ordem de iteração não é relevante.

• Hashtable: é similar ao HashMap, a diferença é que os métodos são sincronizados em relação a thread.

• LinkedHashMap: esse conjunto mantém a ordem de inserção.

• TreeMap: é classificado e é possível especificar como os elementos devem ser comparados entre si quando forem ordenados.

QUEUE: armazena uma lista de “coisas a fazer”, é um tipo de FIFO(primeiro que entrar, primeiro a sair)

• PriorityQueue: esse conjunto criar uma fila com ordenação, assim os elementos são ordenados.

Observação: ao utilizar conjuntos que usem o método Object.hashcode(), por exemplo: HashSet ou LinkedHashSet, iteração ou adição sobre o conjunto. É fundamental que seja feito a sobreescrita correta do hashcode para não permite elementos duplicados.

Classificando Conjuntos
Os conjuntos podem ser classificados de diversas maneiras, por exemplo, um ArrayList de String é classificado alfabeticamente. Para fazer isso é utilizado o método “sort” da classe concreta Collections. Exemplo:
List lista = new ArrayList();
lista.add("B");
lista.add("C");
lista.add("A");
System.out.println(lista); // saída: [B,C,A]
Collections.sort(lista);
System.out.println(lista); // saída: [A,B,C]

Existe ainda a possibilidade de utilizar as interfaces: java.lang.Comparable ou java.util.Comparator, para fazer classificação.
Quando uma classe implementar a interface Comparable é necessário sobreescrever o método: compareTo(Object). E uma classe implementar a interface Comparator é necessário sobreescrever o método: compare(Object,Object).

Classificando Arrays
Os arrays também podem ser classificados, semelhante a Conjuntos. A classificação é feita também através do método “sort” só que é utilizada a classe Arrays. Exemplo:
String [] array = new String[]{“B”,”C”,”A”};
for (String s : array)
System.out.printf(s + “ ”); // saída: B C A
Arrays.sort(array);
for (String s : array)
System.out.printf(s + “ ”); // saída: A B C

Convertendo Arrays em Lista e Listas em Arrays
Existem métodos que permitem converter arrays em Lists e Lists em arrays. As classes do tipo List e Set possuem métodos toArray e a classe Arrays possui o método asList. É importante escrever o que a documentação do método Arrays.asList() explicar:“retorna uma lista de tamanho fixo e modificações feitas na lista são escritas diretamente no array.”. Ou seja, o array e o List ficam unidos como se fossem um só.
Exemplo de Arrays.asList:
String [] sa = {“a”,”b”,”c”};
List sList = Arrays.asList(sa);
Exemplo de toArray():
List lista = new ArrayList();
Integer [] x = (Integer[]) lista.toArray();

observação: o método toArray retorno uma array do tipo Object então é necessário fazer Cast.

Fazendo interação antes do Java 5.
Antes do loop for aprimorado, a maneira mais comum de fazer interação sobre List “elemento por elemento” era com o Iterator. Um Iterador é um objeto associado com um conjunto específico. Os dois métodos que é preciso conhecer para a prova de SCJP são: hasNext(), que retorno um boolean mas não move o próximo elemento e next() que retorno o próximo elemento do conjunto.
Exemplo:
List lista = new ArrayList();
lista.add("B");
lista.add("C");
lista.add("A");
Iterator x = lista.iterator();
while(x.hasNext()){
String ss = x.next(); // devido um iterator ser criado com a sintaxe de genéricos não é preciso fazer cast na chamada do método hext();
}

Como falei no início do post não vou escrever tudo sobre conjuntos, se não ficaria muito cansativo. Assunto relacionados a criação de classes e métodos genéricos ou procura de elementos em um List, são outros assunto que devem ser estudados para a prova. Mas vou escrever alguns tópicos interessantes.

• O método add() da interface Set retorna um boolean(true se o elemento foi inserido ou false se o elemento não foi inserido);

• Não existe o método add() em Map, para adicionar elementos em Map é utilizado put();

• Os métodos peek(),poll() e offer() só são encontrado na interface Queue;

• Para fazer interação em um conjunto, é preciso que os elementos sejam compatíveis, caso isso não aconteça vai ser lançada uma exceção.

• ArrayList o método size() para retornar a quantidade de elementos.

Vou parando por aqui. Espero ter ajudado em alguma coisa e desculpa se escreve alguma besteira. Estamos aqui para qualquer coisa. Críticas, sugestões, reclamações ou qualquer outra coisa para melhorar, é sempre bem vindo.

Abraaaaaaaaço e até a próxima.