Collections
Autor: oberdan martins | Publicado: 2012-02-22T09:12:00-08:00



Quando uma aplicação precisa manipular uma quantidade grande de dados, ela deve utilizar&nbsp;alguma estrutura de dados.&nbsp;Na biblioteca do Java, há diversas estruturas de dados que facilitam o trabalho do desenvolvedor.







Collection → Βase da hierarquia. Representa operações que são comuns a todas as coleções:





add() - para adicionar o elemento especificado à coleção.
remove() - para remover o elemento especificado da coleção.
contains() - para verificar se a coleção contém o elemento especificado.
size() - para obter a quantidade de elementos na coleção.&nbsp;








Set → Não armazena elementos duplicados.&nbsp;

List → Mantém a seqüência de inserção. Pode armazenar elementos duplicados.&nbsp;

Queue → Utilizamos esta interface quando queremos uma coleção do tipo FIFO (Fila).

Map → Relaciona chaves com valores. Não armazena chaves duplicadas.




A figura apresentada pode ser interpretada da seguinte forma: “Um Set,&nbsp;List ou Queue é um tipo de Collection, cada um com suas particularidades. Já um Map&nbsp;não é do mesmo tipo dos demais mas também manipula coleções de elementos”.




SET (HashSet, LinkedHashSet e TreeSet):


O uso dessa interface(Set) é quando a ordenação não tem prioriade e sim de não ter duplicatas.

HashSet - &nbsp;Não estabelece nenhuma ordem particular entre os objetos.
TreeSet - Utiliza-se de uma árvore Binária para alinhar os elementos.
LinkedHashSet - Mantém&nbsp;a ordem de iteração dos elementos

Exemplo:

import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;

public class ExemploSet {

   public static void main(String[] args) {
  
     // Utilizando HashSet
  
     Collection c1 = new HashSet();
  
     c1.add("Andre");
     c1.add("Carlos");
     c1.add("Bruno");
     c1.add("Daniel");
     c1.add("Daniel");
  
     System.out.println("==== HashSet ====");
  
     for(String str : c1) {
        System.out.println(str);
     }
  
     // Utilizando TreeSet
  
     System.out.println("==== TreeSet ====");
  
     Collection c2 = new TreeSet(c1);
  
     for(String str : c2) {
        System.out.println(str);
     }
  
     // Utilizando LinkedHashSet 
  
     System.out.println("==== LinkedHashSet ====");
  
     Collection c3 = new LinkedHashSet(c1);
  
     for(String str : c3) {
        System.out.println(str);
     }
  
  }
}

A saída será: (Perceba que mesmo tendo inserido 2 vezes o nome "Daniel", ele só aparece uma vez):


==== HashSet ====
Andre
Daniel
Carlos
Bruno
==== TreeSet ====
Andre
Bruno
Carlos
Daniel
==== LinkedHashSet ====
Andre
Carlos
Bruno
Daniel


LIST&nbsp;(ArrayList, Vector e LinkedList):

Devemos utilizar um List&nbsp;quando a ordem de inserção ou a posição na coleção nos interessa.


ArrayList&nbsp;- &nbsp;Pode ser visto como um array dinâmico.

Vector&nbsp;- Basicamente um ArrayList, no entanto seus métodos são&nbsp;sincronizados

LinkedList&nbsp;- Todos os elementos são ligados entre si.



Exemplo:


Obs:&nbsp;ArrayList e&nbsp;LinkedList seguem a mesma interface, List. Portanto, é possível realizar as mesmas operações nas duas listas.

import java.util.ArrayList;
import java.util.Collections;

public class ExemploList {
   public static void main(String[] args) {
  
     //Criando um ArrayList.
     ArrayList lista = new ArrayList();
  
     //Para adicionar elementos ao final da lista, usamos o método add 
     lista.add("Sao Paulo");
     lista.add("Belo Horizonte");
     lista.add("Rio de Janeiro");
     lista.add("Bahia");
     lista.add("Amazonia");
     imprime("Elementos adicionados ate agora", lista);
  
  
     //Para adicionar em uma posicão especifica utilizamos o indice
     lista.add(1, "Parana");
     lista.add(3, "Acre");
     imprime("Lista depois de adicionar mais dois elementos", lista);
  
  
     //Podemos acessar um elemento da lista usando get
     System.out.println("O 3° elemento da lista é: " + lista.get(2));
  
  
     //Podemos obter o tamanho da lista utilizando o método size()
     System.out.println("O tamanho da lista é: " + lista.size());
  
  
     //Utilizamos remove para remover um elemento da lista
     lista.remove("Amazonia");
     imprime("Lista depois de remover 'Amazonia'", lista);
  
  
     //Podemos verificar se existe algum elemento na lista
     if(lista.contains("Sao Paulo"))
        System.out.println("Sao Paulo existe");
     else
        System.out.println("Sao Paulo não existe");
  
     if(lista.contains("Ceara"))
        System.out.println("Ceara existe");
     else
        System.out.println("Ceara não existe");
  
  
     //Podemos ordenar uma lista utilizando o sort
     Collections.sort(lista);
     imprime("Lista ordenada", lista);
  
  }
 
    // Percorre todos elementos de qualquer coleção
  
    private static void imprime(String titulo, ArrayList lista) {
       System.out.println(titulo + ":");
       for(String str : lista) {
          System.out.println(str);
       }
       System.out.println();
   }
}


O Vector não é mais utilizado, é uma classe antiga, anterior a Collections Framework e hoje não há mais motivos para usa-la. O ArrayList é seu substituto direto.



Existe uma diferença entre o&nbsp;&nbsp;ArrayList e o LinkedList.&nbsp;



&nbsp;A diferença é que o ArrayList baseia num array convencional, portanto, é fácil acessar qualquer elemento e inserir objetos no final do array. Por outro lado, é mais custoso inserir elementos no meio do array, pois alguns elementos terão de ser deslocados.&nbsp;



&nbsp;Já o LinkedList é uma lista duplamente encadeada. Isso quer dizer que é fácil inserir objetos em qualquer ponto da lista, mas é muito complicado acessar uma posição específica (o java terá que percorrer a lista toda até chegar lá).



MAP&nbsp;(Hashtable, LinkedHashMap, HashMap e TreeMap):





Um Map identifica seus elementos&nbsp;através de chave / valor



HashMap&nbsp;- &nbsp;É&nbsp;um Map desorganizado, isto é, a ordem de iteração dos&nbsp;elementos é desconhecida



Hashtable&nbsp;- Similar ao&nbsp;HashMap, porém&nbsp;não aceita valor&nbsp;&nbsp;nulo&nbsp;tanto para chaves quanto&nbsp;para valores.



LinkedHashMap&nbsp;- Similar ao LinkedHashSet, porém esta é a versão que implementa a&nbsp;interface Map

TreeMap - Ordena seus elementos através da chave por&nbsp;alguma regra.




Exemplo:

Um exemplo simples e prático de uso de map seria para um sistema de biblioteca, onde cada livro possui um código para busca:

public class Livro {
 
    private String codigo = "";
    private String nome = "";
 
    public String getCodigo() {
       return codigo;
    }
 
    public void setCodigo(String codigo) {
       this.codigo = codigo;
    }
 
    public String getNome() {
       return nome;
    }

    public void setNome(String nome) {
       this.nome = nome;
    }
}

import java.util.HashMap;

public class Biblioteca {
   public static void main(String[] args) {
  
     // os objetos entre as tags &lt; &gt; definem os valores fixos de chave
     // e valor que usaremos durante todo nosso programa
  
     HashMap mp = new HashMap();
  
     Livro livro1 = new Livro();
     livro1.setCodigo("java1");
     livro1.setNome("Java como programar");
     mp.put("java1", livro1);
  
     Livro livro2 = new Livro();
     livro2.setCodigo("BD2");
     livro2.setNome("Aprendendo MySQL");
     mp.put("BD2", livro2);
  
     Livro livro3 = new Livro();
     livro3.setCodigo("Html3");
     livro3.setNome("Joomla fácil");
     mp.put("Html3", livro3);
  
     // Acessando um valor através de uma chave
     Livro livro = mp.get("Html3");
     System.out.println(livro.getNome());
  }
}

Por hoje é isso!!! Estejam livres para comentar ou dar sugestões!

&nbsp;Thanks!