10 de agosto de 2010

Collections: Estruturas de dados

São tipos de dados compostos, diferentemente dos tipos: int, double, float, entre outros que são tipos de dados primitivos. As estruturas de dados são formas de armazenamento de dados ou objetos.
Por exemplo, os arrays são estruturas de dados lineares e estáticas para armazenar dados, porém com capacidade limitada, ou seja deve-se inicializá-lo com um tamanho. Para aumentar essa capacidade durante a execução da aplicação teria que haver um algoritmo que aumente a capacidade de informações do array.


Código-fonte:
System.out.println("-------------------Arrays-------------------");
 //inicializando array com 3 posições
 String[] array = new String[3];

 //inserindo elementos
 array[0] = "A";
 array[1] = "B";
 array[2] = "C";

 //ou
 // inicializando array com 3 elementos
 String[] array2 = { "A", "B", "C" };

 //percorrendo o array para fazer a listagem dos dados
 for (int i = 0; i < array2.length; i++){
     System.out.println(array2[i]);
 }
Resultado:
-------------------Arrays-------------------
A
B
C

Estruturas de dados Java
As estruturas de dados Java se encontram no pacote java.util. As operações básicas dessas estruturas são: adição, remoção, acesso e pesquisa. Podemos tratar uma estrutura de dados como uma coleção, pois este permite armazenar vários objetos. Os tipos de coleções estudados serão: Listas, Conjuntos e Mapas.
Listas As listas são estruturas de dados dinâmicas. Os elementos são arrumados numa ordem linear, ou seja, os elementos possuem sucessor (com exceção do ultimo elemento) e antecessor (com exceção do primeiro elemento). Alguns tipos de listas são: LIFO  e FIFO Exemplo de lista: java.util.List Pilhas (LIFO): Last in, First out [Ultimo que entra, primeiro que sai] Os elementos de uma pilha são adicionados ao topo e removidos do topo também. Exemplo: java.util.Stack
Código Fonte:
System.out.println("-------------------Pilhas-------------------");
        //criando a pilha
        Stack pilha = new Stack();
        //inserindo valores na pilha
        pilha.push("A");
        pilha.push("B");
        pilha.push("C");
        pilha.push(12.6);
        //pegando o topo da pilha
        System.out.println("Topo: " + pilha.peek());
        //percorrendo a pilha
        for (int i = 0; i < pilha.size(); i++){
            System.out.println(pilha.get(i));
        }
        //removendo um elemento, e por ser uma pilha
        //ele removerá o elemento que foi inserido por ultimo
        pilha.pop();
        System.out.println("Depois de remover um elemento:");
        //percorrendo a pilha novamente
        for (int i = 0; i < pilha.size(); i++){
            System.out.println(pilha.get(i));
        }
Resultado:
-------------------Pilhas-------------------
Topo: 12.6
A
B
C
12.6
Depois de remover um elemento:
A
B
C

Filas (FIFO): First in, First out [Primeiro que entra, primeiro que sai] Os elementos de uma pilha são adicionados ao final da fila e removidos do topo da mesma. Exemplo: java.util.Queue
Código Fonte:
System.out.println("-------------------Filas-------------------");
        //criando a fila, Queue é apenas uma interface,
        //então utilizaremos a implentação LinkedList
        Queue fila = new LinkedList();
        //inserindo elementos na fila
        fila.add("A");
        fila.add("B");
        fila.add("C");
        fila.add(12.6);
        //pegando o topo da fila
        System.out.println("Topo: " + fila.peek());
        //percorrendo a fila, este é outra forma de percorrer uma lista
        //o Object é o tipo do elemento, o obj é o elemento e a fila é nossa lista
        // o obj corresponderia ao get(i) da pilha
        for (Object obj : fila){
            System.out.println(obj);
        }
        //removendo um elemento, e por ser uma fila
        //ele removerá o elemento que foi inserido por primeiro
        fila.remove();
        System.out.println("Depois de remover um elemento:");
        //percorrendo a fila novamente
        for (Object obj : fila) {
            System.out.println(obj);
        }
Resultado:
-------------------Filas-------------------
Topo: A
A
B
C
12.6
Depois de remover um elemento:
B
C
12.6

Para entender melhor o funcionamento de pilha e fila, compare o resultado dos exemplos, pois os dois códigos fazem a mesma coisa, porém de formas diferentes.
Conjuntos
Os conjuntos não permitem que seja inseridos elementos duplicados num mesmo conjunto, e também não tem uma ordem dos elementos como nas listas, assim como os conjuntos matemáticos.
Exemplo: java.util.Set Mapas
Um mapa armazena pares (chave, valor), essa chaves e valores podem ser de qualquer tipo. A chave é utilizada para achar um elemento rapidamente. Um mapa normalmente implementada como “Tabela Hash”. Exemplo: java.util.Map
Tabela Hash
Também chamada de: Tabela de dispersão ou tabela de espalhamento ou tabela hashing. É uma estrutura de dados especial, que associa chaves de pesquisa a valores. O objetivo é, a partir de uma chave simples, fazer uma busca rápida e obter o valor desejado.
Java Collection Framework 
"Desde a versão 1.2 do JDK (depois que o renomearam para Java 2 SDK), a plataforma J2SE inclui um framework de coleções (a Collections Framework). Uma coleção é um objeto que representa um grupo de objetos. Um framework de coleções é uma arquitetura unificada para representação e manipulação de coleções, permitindo que elas sejam manipuladas independentemente dos detalhes de sua implementação."
Mais informações sobre o framework: http://javafree.uol.com.br/artigo/847654/
Estrutura do framework:



Collection: Interface base para todos os tipos de coleções.
Set: Contém apenas os métodos herdados de Collection e adiciona a restrição de que elementos duplicados não são permitidos.
Exemplo:java.util.Set
Codigo-fonte:
System.out.println("---------------Collection----------------");
       System.out.println("-------------------Set-------------------");
       //criando um set, como Set é interface, vamos utilizar a implementação HashSet
       Set< String > set = new HashSet< String >();
       //inserindo elementos
       set.add("A");
       set.add("B");
       set.add("C");
       set.add("A");
       //removendo elemento "C"
       set.remove("C");
       //percorrendo a coleção
       for (String obj : set){
           System.out.println(obj);
       }
Resultado:
---------------Collection----------------
-------------------Set-------------------
A
B

SortedSet:Usaremos implementações de SortedSet para situações onde desejarmos ordenar os elementos.
Exemplo: java.util.SortedSet
Codigo-fonte:
System.out.println("-------------------SortedSet-------------------");
       //criando um set ordenado, como SortedSet é interface, vamos utilizar a implementação TreeSet
       SortedSet< String > setOrdenado = new TreeSet< String >();
       //inserindo elementos
       setOrdenado.add("B");
       setOrdenado.add("A");
       setOrdenado.add("C");
       setOrdenado.add("A");
       //percorrendo o conjunto
       for (String obj : setOrdenado){
           System.out.println(obj);
       }
Resultado:
-------------------SortedSet-------------------
A
B
C


List: É uma coleção ordenada que pode conter valores duplicados. Além disso, temos controle total sobre a posição onde se encontra cada elemento de nossa coleção, podendo acessar cada um deles pelo índice.
Exemplo:java.util.List Codigo-fonte:
System.out.println("-------------------List-------------------");
       //criando um list, como List é interface, vamos utilizar a implementação ArrayList
       List< String > list = new ArrayList< String >();
       //inserindo elementos na lista
       list.add("A");
       list.add("C");
       list.add("E");
       //perconrrendo a lista
       System.out.println("Lista Atual");
       for (String obj: list){
           System.out.println(obj);
       }
       //inserindo um elemento numa determinada posição da lista
       list.add(1, "B");
       //perconrrendo a lista
       System.out.println("Lista com novo elemento");
       for (String obj: list){
           System.out.println(obj);
       }
       //substituindo o elemendo de uma determinada posição
       list.set(3, "D");
       //perconrrendo a lista
       System.out.println("Lista com elemento substituido");
       for (String obj: list){
           System.out.println(obj);
       }
Resultado:
-------------------List-------------------
Lista Atual
A
C
E
Lista com novo elemento
A
B
C
E
Lista com elemento substituido
A
B
C
D


Queue: Normalmente utilizamos esta interface quando queremos uma coleção do tipo fila (FIFO).
Exemplo: java.util.Queue Codigo-fonte e resultado já apresentado em Filas.


Map: Map não é uma Collection pois uma Collection não trabalha com chaves. Utilizada em relações de chave-valor entre os elementos. Cada chave pode conter apenas um único valor associado.
Exemplo: java.util.Map
Codigo-fonte:
System.out.println("-------------------Map-------------------");
       //criando um mapa, Map é interface, HashMap é a implementação
       Map< String, String > mapa = new HashMap< String, String >();
       //inserindo elementos no mapa: ex: a -> chave ; Letra A -> valor
       mapa.put("a", "Letra A");
       mapa.put("b", "Letra B");
       mapa.put("c", "Letra C");
       //removendo pela chave
       mapa.remove("a");
       //listando os elementos do mapa
       System.out.println("Listagem: " + mapa);
       //pegando um valor a partir do mapa
       System.out.println("Pegar a partir chave b: " + mapa.get("b"));
Resultado:
-------------------Map-------------------
Listagem: {b=Letra B, c=Letra C}
Pegar a partir chave b: Letra B


SortedMap: Usaremos SortedMap para situações onde desejarmos ordenar os elementos, esses elementos são ordenados pela chave e não pelo valor.
Exemplo: java.util.SortedMap
Codigo-fonte:
System.out.println("-------------------SortedMap-------------------");
       //criando um mapa ordenado
       SortedMap< String, String > mapaOrdenado = new TreeMap< String, String >();
       //inserindo elementos no mapa
       mapaOrdenado.put ("um", "11111");
       mapaOrdenado.put ("dois", "222222");
       mapaOrdenado.put ("tres", "33333");
       //listando os elementos do mapa
       System.out.println ("Listando: " + mapaOrdenado);
       //como a chave é uma String, a ordenação da mesma será por ordem alfabética
Resultado:
-------------------SortedMap-------------------
Listando: {dois=222222, tres=33333, um=11111}


Obs: para executar os exemplos, crie uma classe com um método main e para executar no Netbeans utilize : Shift + F6
Exemplo:
public class Collections {

    public static void main(String[] args) {
        //Código-fonte aqui.!
    }
}
Referências: http://www.dsc.ufcg.edu.br/~jacques/cursos/p2/html/ed/colecoes.htm http://download.oracle.com/javase/tutorial/collections/index.html

4 comentários:

  1. Ótimo post... Didático e completo .Muito bom mesmo.

    ResponderExcluir
  2. Os exemplos são simples, fáceis de serem entendidos! Me ajudou a montar uma apresentação! Obrigada...

    ResponderExcluir
  3. Olá Patricia! Fico feliz por ter ajudado :)

    ResponderExcluir

Deixe seu comentário... ;)