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.StackCó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.
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/
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.SetCodigo-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.SortedSetCodigo-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.
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).
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.
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.
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
Ótimo post... Didático e completo .Muito bom mesmo.
ResponderExcluirObrigada EmilioFilho! :)
ResponderExcluirOs exemplos são simples, fáceis de serem entendidos! Me ajudou a montar uma apresentação! Obrigada...
ResponderExcluirOlá Patricia! Fico feliz por ter ajudado :)
ResponderExcluir