Coleções em Java – List

Uma lista é uma coleção ordenada de elementos do mesmo tipo, conhecida por seqüência. Os elementos de uma lista podem ser acessados pela sua posição, isto é, seu índice.

OBS.: o primeiro elemento de qualquer lista tem índice 0 (zero).

As listas são derivadas da interface java.util.List, que por sua vez, estende a interface Collection.

As listas podem receber elementos iguais, ou seja, dois objetos x1 e x2, onde x1.equals(x2) retorna verdadeiro, além de múltiplos null.

A interface List possui um iterator especial, o ListIterator, que permite o início da iteração em qualquer ponto da lista.

List possui os seguintes novos métodos (além dos que “vieram” de Collection):

* void add(int i, E elemento) » adiciona um elemento do tipo E à lista, na posição i;
* boolean addAll(int i, Collection c) » adiciona todos os elementos de uma coleção c à lista, na posição i;
* E get(int i) » retorna o elemento do tipo E, que está na posição i; int indexOf(Object o) » retorna a posição do primeiro objeto o da lista – se ele não existir, retorna -1;
* Iterator iterator() » retorna um iterator, que será usado para percorrer todos os elementos da lista; int lastIndexOf(Object o) » retorna a posição do último objeto o da lista – se ele não existir, retorna -1;

* ListIterator listIterator() » retorna um iterator específico para listas, que será usado para percorrer todos os elementos da mesma;
* ListIterator listIterator(int i) » retorna um iterator específico para listas, que será usado para percorrer todos os elementos da mesma, a partir da posição i;
* boolean remove(int i) » remove o elemento que está na posição i da coleção;

* E set(int i, E elemento) » substitui o elemento que está na posição i pelo emento que foi passado como argumento – o elemento antigo é retornado pelo método;
* List subList(int inicio, int fim) » retorna uma lista com todos os elementos da lista original, compreendidos entre inicio (inclusive) e fim (exclusive);

OBS.: Collection c quer dizer: objeto c, do tipo Collection, que contém elementos do mesmo tipo da coleção que está executando o método.

Retirado de: http://www.50minutos.com.br/?p=60

Tutorial Java – Arrays e Coleções

Introdução

O array é um grupo de posições contínuas na memória que possuem o mesmo nome e o mesmo tipo. Para referir-se a uma localização ou elemento particular no array, especificamos o nome do array e o número da posição(ou índice ou subscrito) do elemento particular no array.

1. Array

Um array em Java é tratado como um objeto, afinal ele advém da classe Array, e como todo objeto, é preciso:

1)Declará-lo. Exemplo: int[] meuArray;
2)Construí-lo. Exemplo: meuArray = new int[2];
3)Inicializar. Exemplo: meuArray[0] = 2; meuArray[1] = 4.

Neste caso foi criado um array com uma dimensão e duas posições do tipo inteiro, note os colchetes (“[]”). Cada conjunto indica uma dimensão. Como ilustração, podemos imaginar como exemplo, uma gaveta contendo várias pastas onde a posição de cada pasta seria uma posição do array. A posição zero seria o primeiro elemento, posição 1 o segundo elemento e assim por diante até o último elemento(n -1).

Vamos supor que desejamos construir um array de números inteiros. Então devemos realizar uma declaração do mesmo, como segue:

int[] meuArray;

O próximo passo é construir. Para isto, vamos definir que o array terá dez posições:
meuArray = new int[10];

Vamos iniciar as cinco primeiras posições do array com valores:

meuArray[0] = 22;
meuArray[1] = 2;
meuArray[2] = 242;
meuArray[3] = 4552;
meuArray[4] = 36.

Agora, vamos construir um laço de repetição for para percorrer os elementos e produzir uma saída no terminal:

for (int i = 0; i < meuArray.length; i++){
System.out.println(“posição ” + i + ” = ” + meuArray[i]);
]

O código completo fica desta maneira:

public class MeuArray {

public static void main( String args[]){
int[] meuArray;
meuArray = new int[10];
meuArray[0] = 22;
meuArray[1] = 2;
meuArray[2] = 242;
meuArray[3] = 4552;
meuArray[4] = 36;

for (int i = 0; i < meuArray.length; i++){
System.out.println(“posição ” + i + ” = ” + meuArray[i]);
}

}

}

O programa ao ser executado vai produzir uma saída no terminal:

posição 0 = 22
posição 1 = 2
posição 2 = 242
posição 3 = 4552
posição 4 = 36
posição 5 = 0
posição 6 = 0
posição 7 = 0
posição 8 = 0
posição 9 = 0

Note que um dos parâmetros dentro da estrutura de repetição for é o método que obtém o tamanho do array, “length”.
Este método aplicado ao objeto meuArray(meuArray.length), retorna um número inteiro correspondente ao tamanho do array.
Existe uma classe que auxilia a utilização de array, que está localizada no pacote java.util, tem o nome de Arrays, e possui os seguintes métodos:

* binarySearch – permite uma pesquisa nos elementos de um determinado array ordenado, retornando um atributo inteiro com a posição deste elemento;
* equal – permite a comparação entre dois arrays, retornando um booleao verdadeiro(true), caso os array sejam iguais;
* fill – realiza o preenchimento de todos os elementos de um determinado array;
* sort – faz uma ordenação nos elementos de um determinado array;
* toString – mostra os elementos de um determinado array.

Uma outra forma de inicializar um array, seria declarar o array já inicializando-o com valores:

int[] meuArray = {22,2,242,4552,36};

Suponha agora que desejamos descobrir no objeto meuArray a posição que contem o elemento 4552. O método binarySearch da classe Arrays é o mais indicado para isto, porém, no array meuArray não está ordenado, sendo uma condição para utilização do método binarySearch . O primeiro passo então seria ordenar o meuArray utilizando o método sort:

java.util.Arrays.sort(meuArray);

Agora podemos utilizar o método binarySearch desta maneira:

java.util.Arrays.binarySearch(meuArray,4552);

Alterando o código exemplo temos:

public class MeuArray {

public static void main( String args[]){
int[] meuArray;
meuArray = new int[10];
meuArray[0] = 22;
meuArray[1] = 2;
meuArray[2] = 242;
meuArray[3] = 4552;
meuArray[4] = 36;

java.util.Arrays.sort(meuArray);

for (int i = 0; i < meuArray.length; i++){
System.out.println(“posição ” + i + ” = ” + meuArray[i]);
}

System.out.println(“posição do elemento 4552 :” + java.util.Arrays.binarySearch(meuArray,4552));

}

}

Vamos agora construir um objeto array idêntico ao meuArray da seguinte forma:

int [] espelho = meuArray;

O método equals da classe Arrays, permite comparar dois arrays retornando “true” ou “false”, como mostra o código a seguir::

if (java.util.Arrays.equals(meuArray,espelho)){
System.out.println(“são identicos…”);
}else{
System.out.println(“são diferentes…”);
}

O método fill da classe Arrays, preenche todos os elementos de um array com um dado valor, da seguinte forma:

java.util.Arrays.fill(espelho,5522);

Percorrendo todos os elementos deste array verificamos que os valores são os mesmos para todas as posições do array espelho:

posição 0 = 5522
posição 1 = 5522
posição 2 = 5522
posição 3 = 5522
posição 4 = 5522
posição 5 = 5522
posição 6 = 5522
posição 7 = 5522
posição 8 = 5522
posição 9 = 5522

Para finalizar, o método toString() da classe Arrays permite exibir todos elementos de um objeto array, como mostra o código a seguir:
System.out.println(“Conteúdo do objeto array : ” + java.util.Arrays.toString(meuArray));

public class MeuArray {

public static void main( String args[]){
int[] meuArray;
meuArray = new int[10];
meuArray[0] = 22;
meuArray[1] = 2;
meuArray[2] = 242;
meuArray[3] = 4552;
meuArray[4] = 36;

java.util.Arrays.sort(meuArray);

for (int i = 0; i < meuArray.length; i++){
System.out.println(“posição ” + i + ” = ” + meuArray[i]);
}

System.out.println(“Conteúdo do objeto array : ” + java.util.Arrays.toString(meuArray));

System.out.println(“posição do elemento 4552 :” + java.util.Arrays.binarySearch(meuArray,4552));

int [] espelho = meuArray;

if (java.util.Arrays.equals(meuArray,espelho)){
System.out.println(“são identicos…”);
else{
System.out.println(“são diferentes…”);
}

java.util.Arrays.fill(espelho,5522);

for (int j = 0; j < meuArray.length; j++){
System.out.println(“posição ” + j + ” = ” + meuArray[j]);
}

System.out.println(“Conteúdo do objeto array : ” + java.util.Arrays.toString(meuArray));

}

}

A saída produzida no terminal é a que segue:

Conteúdo do objeto array : [0, 0, 0, 0, 0, 2, 22, 36, 242, 4552]

Para entender com é u arrray com mais de uma dimensão, pense que uma dimensão de um array seria como uma gaveta com pastas, e duas dimensões seria um armário completo. Assim, para localizarmos uma pasta é necessário localizar primeiro qual gaveta, para depois localizar a pasta dentro desta gaveta.
Observe o código a seguir:

public class Armario {

/** Inicia programa Armario */
public static void main (String args[]){

String [][] dado = new String[3][3];

for (int gaveta = 0 ; gaveta < dado.length; gaveta++){
for(int pasta = 0; pasta < dado[gaveta].length; pasta++){
dado[gaveta][pasta] = “Gaveta ” + gaveta + ” pasta ” + pasta;
}
}

for (int gaveta = 0 ; gaveta < dado.length; gaveta++){
for(int pasta = 0; pasta = 1){
for (int i = incr; i = incr && temp < meuarray[j – incr]){
meuarray[j] = meuarray[j – incr];
j -= incr;
}
meuarray[j] = temp;
}
incr /= 2;
}
}

public static void printarray(int[] a){
String var = “”;
for (int i = 0; i < a.length; i++){
var = var.concat(a[i] + “\n\r”);

}

JOptionPane.showMessageDialog( null, var, “Array ordenado”, JOptionPane.INFORMATION_MESSAGE );
}

public static void main(String[] args){
// constroi um array com dez inteiro
int[] meuarray = new int[10];

int i;

// preenche o array com valores randomicos
for (i = 0; i < meuarray.length; i++)
meuarray[i] = (int)(Math.random() * 100);
printarray(meuarray);
ordena(meuarray);
printarray(meuarray);
}
}

2. Vetores

Em muitas linguagens de programação – em particular C – é necessário fixar o tamanho de todos os arrays em tempo de compilação. Os programadores odeiam isto porque os força a fazerem suposições e assumirem compromissos desconfortáveis.
Em Java, a situação é muito melhor. Pode-se definir o tamanho de um array em tempo de execução.

int n;
…
Item[] itensPedidos = new Item[n+1];

É claro, esse código não resolve totalmente o problema de modificar dinamicamente arrays em tempo de execução. Uma vez definido o tamanho do array, não se pode alterá-lo facilmente. Em vez disso, a maneira mais fácil de lidar com essa situação comum em Java é usar outro objeto Java que funcione como um array e que cresça ou diminua automaticamente. Esse objeto é chamado de vetor(vector). Assim, em Java, os vetores são objetos parecidos com arrays que podem crescer ou diminuir automaticamente sem que seja necessário escrever nenhum código para isso.

Há uma diferença importante entre vetor e um array. Os arrays são um recurso da linguagem Java e há um tipo de array T[] para cada elemento do tipo T. Contudo, a classe Vector é uma classe de biblioteca, definida no pacote java.util, e há “um único tamanho de vetor que atende a todos” contendo elementos do tipo Object. Em particular, será necessário uma conversão de tipo sempre que se quiser obter um itm de um vetor.
Cria-se um novo vetor especificando sua capacidade inicial no construtor Vector.

Vector itensOrdenados = new Vector(3);
// começa com espaço para um item pedido,
// mais dois itens para encargos de remessa a taxas

Há um importante distinção entre a capacidade de um vetor e o tomanho de um array. Se você reservar um array com três itens, então o array terá três entradas prontas para serem usadas. Um vetor com uma capacidade de três elementos tem potencial de conter três elementos (e, na verdade, mais de três), mas no início, mesmo depois de sua construção inicial, um vetor não contém elemento nenhum.
Use o método add para adicionar novos elementos a um vetor. Por exemplo, suponhamos que você tenha uma classe chamada Item e use código a seguir para criar três objetos Item.

Item proxItem = new Item(…);
Item ICMS = new Item(…);
Item remessa = new Item(…);

Depois, use o código a seguir para adicionar esses itens a um vetor chamado itensOrdenados(que começa com uma capacidade de três objetos, conforme indicado no código).

itensOrdenados.add(proxItem);
itensOrdenados.add(ICMS);
itensOrdenados.add(remessa);

Suponhamos que você criou o vetor de modo que tenha uma capacidade original de três itens. Se você inserir outro item, então terá execido a capacidade do vetor do nosso exemplo. É aqui que os vetores fazem sua mágica: o vetor se redimensiona e realoca memória automáticamente. O vetor encontra uma área maior de memória e copia automaticamente todos os objetos que ele contém atualmente para esse local.
Quanto espaço é alocado? A priori, o espaço alocado dobra cada vez que o vetor é redimendionado. Devido ao problema de crescimento exponencial em potencial, talvez não se queira contar com esse processedimento para realocar a grande quantidade de memória usada em vetores grandes. Em vez disso, pode-se especificar um incremento de capacidade como segundo argumento do construtor ao ser criado o vetor. Por exemplo:

Vetor itensOrdenados = new Vector (3,10);

Agora o vetor vai crescer com incremento de 10 em cada realocação.
Por outro lado, se um programa Java tiver de realocar o espaço de um vetor frequentemente, isso vai reduzir o desempenho do programa, de modo que é importante fazer uma estimativa razoável da capacidade inicial e do incremento da capacidade – em que 10 pode ser um incremento muito pequeno.

Vector()
Constrói um vetor vázio (com capacidade inicial 10 e incremento de capacidade igual ao dobro sempre qua a capacidade atual é excedida).

Vector(int capacidadeInicial)
Constrói um vetor vazio com a capacidade especificada.

Vector(int capacidadeInicial, int incrementoCapacidade)
Constrói um vetor vázio com capacidade especificada e o incremento especificado)

boolean add(Object)
Adiciona um elemento ao final do vetor de modo que se torne o último elemento do vetor. Sempre retorna true (verdadeiro).

void set size(int i)
Especifica o tamanho do vetor em n elementos exatamente. Se n for maior que o tamanho atual, serão adicionados elementos nulos ao final do vetor. Se n for menos que o tamanho atual, todos os elementos de índice n em diante serão removidos.

void set (int indice, Object obj)
Coloca um valor no vetor em um índice especificado, sobrescrevendo o conteúdo anterior.

Object get (int indice)
Obtém o valor armazenado em um índice especificado.

add (int indice, Object obj)
Desloca para cima os elementos para poder inserir um outro elemento.

3. Coleções

Estruturas de dados são mecanismos para manipular coleções de elementos em um programa. O pacote java.util oferece algumas classes pré-definidas na API padrão de Java que implementam funcionalidades associadas a estruturas de dados.
As classes de coleções da API Java compõem o chamado framework de coleções, que foi completamente redefinido a partir da versão 1.2 de Java. As classes até então existentes, as classes de coleção históricas, foram reprojetadas para se adequar ao novo framework e são mantidas por motivos de compatibilidade, embora a recomendação seja utilizar as novas classes de coleções.
O framework de coleções foi introduzido a partir da plataforma Java 2, oferecendo um novo modelo de classes e interfaces para a manipulação de estruturas de dados. O modelo histórico não foi descontinuado, havendo ocorrido algumas adaptações quando necessário para adequar suas classes ao novo framework.
O framework tem por raiz duas interfaces básicas: Collection, usada para a manipulação de coleções onde os elementos são objetos individuais, e Map, usada para a manipulação de estruturas de pares de objetos, sendo um deles usado como a chave de acesso.
Um objeto Collection representa um agrupamento genérico de objetos simples. Objetos que implementam esta interface devem manter uma estrutura interna que permita acrescentar objetos à coleção, removê-los e consultar se um objeto é ou não parte da coleção.
Entre os métodos básicos especificados nesta interface estão:

* 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.

Para percorrer os elementos de uma coleção, um objeto Iterator é utilizado. O método iterator() é usado para obter esse objeto que permite varrer todos os elementos da coleção.
A interface Iterator associa, a cada coleção, um mecanismo para percorrer seu conteúdo independentemente da sua estrutura interna. Um objeto desta classe oferece os métodos:

* hasNext() para indicar se há mais elementos na coleção;
* next() para obter o próximo elemento da coleção; e
* remove() para retirar um elemento da coleção.

A interface ListIterator � uma extensão de Iterator que permite a varredura da coleção nas duas direções, especificando adicionalmente os métodos hasPrevious() e previous().
Duas outras interfaces são derivadas de Collection, Set e List. São especificações que de alguma forma restrigem ou complementam as funcionalidades básicas especificadas em Collection.

A interface Set é uma extensão de Collection que não acrescenta nenhum método à especificação básica. No entanto, o comportamento dessa coleção é diferenciado, pois um objeto Set não armazena duas referências para um mesmo objeto — apenas uma cópia é admitida.

A interface SortedSet é uma extensão de Set que agrega o conceito de ordenação ao conjunto. Para tanto, os elementos de um SortedSet devem ser comparáveis.

Novos métodos que fazem uso dessa propriedade foram introduzidos, tais como:

* first() para obter o primeiro elemento do conjunto.
* last() para obter o último elemento do conjunto.
* subSet() para obter o subconjunto com todos os elementos contidos entre dois elementos especificados.

A interface List é uma extensão de Collection que acrescenta ao agrupamento o conceito de indexação, ou seja, informação sobre a posição do elemento em relação aos demais membros do grupo.

Além dos métodos básicos de coleções, um objeto List tem métodos tais como:

* get() para obter o elemento armazenado na posição especificada;
* indexOf() para obter a posição da primeira ocorrência do elemento especificado; e
* subList() para obter uma sublista contendo os elementos compreendidos entre dois elementos especificados, incluindo o primeiro deles mas não o segundo.

A interface Map especifica as funcionalidades necessárias para manipular um grupo de objetos onde cada elemento é um par que associa um objeto chave a um objeto valor.
Entre outros, os seguintes métodos são oferecidos:

* put(), que associa um novo objeto valor ao objeto chave especificado;
* get(), que retorna o objeto valor associado ao objeto chave especificado;
* containsKey(), que indica se a chave especificada está presente na coleção;
* size(), que retorna a quantidade de elementos (pares chave-valor) na coleção.

Se adicionalmente deseja-se que esse grupo de pares de objetos seja mantido por ordem dos valores das chaves, a interface mais especializada SortedMap pode ser utilizada, desde que os objetos usados como chave sejam comparáveis.

Além das funcionalidades acima, esta interface acrescenta a especificação de métodos tais como:

* firstKey() para retornar o elemento da coleção com a chave de menor valor.
* lastKey() para retornar o elemento da coleção com a chave de maior valor.
* subMap() para obter o subconjunto dos elementos compreendidos entre as chaves especificadas.

A API de Java oferece algumas implementações para essas interfaces, tais como HashMap e TreeMap

4. Exemplo ArrayList

// Pacotes Java
import java.awt.Color;
import java.util.*;
import javax.swing.JOptionPane;

public class TesteColecao {
private String colors[] = { “vervelha”, “branca”, “azul” };

// cria um ArrayList, adiciona objetos e manipula
public TesteColecao()
{
ArrayList list = new ArrayList();
String var = “”;

// Adiciona um objeto para lista
list.add( Color.magenta ); // Adiciona um objeto color

for ( int count = 0; count < colors.length; count++ )
list.add( colors[ count ] );

list.add( Color.cyan ); // Adiciona um objeto color

// saída do conteúdo da lista
var = “ArrayList: \n\r”;

for ( int count = 0; count < list.size(); count++ )
var += list.get( count ) + “\n\r “;

JOptionPane.showMessageDialog( null, var, “ArrayList”, JOptionPane.INFORMATION_MESSAGE );
// remove todos os objetos String
removeStrings( list );

// saída do conteúdo da lista
var = “ArrayList depos da chamada remove Strings: \n\r”;

for ( int count = 0; count < list.size(); count++ ){
var += list.get( count ) + “\n\r “;

}
JOptionPane.showMessageDialog( null, var, “ArrayList”, JOptionPane.INFORMATION_MESSAGE );
}

// remove objetos String objects da Coleção
public void removeStrings( Collection collection )
{
// recebe iterator
Iterator iterator = collection.iterator();

// laço de repetição while na coleção verifica item
while ( iterator.hasNext() )

if ( iterator.next() instanceof String )
iterator.remove(); // remove objeto String
}

// executa aplicação
public static void main( String args[] )
{
new TesteColecao();
}

} // fim da classe TesteColecao

5. Exemplo LinkedList

import java.util.*;
import javax.swing.JOptionPane;

public class TesteList {
private String colors[] = { “preta”, “amarela”, “verde”,
“azul”, “violeta”, “prata” };
private String colors2[] = { “ouro”, “branca”, “marrom”,
“azul”, “cinza”, “prata” };

// atribuir e manipular objetos LinkedList
public TesteList()
{
LinkedList link = new LinkedList();
LinkedList link2 = new LinkedList();

// adiciona elementos para cada lista
for ( int count = 0; count < colors.length; count++ ) {
link.add( colors[ count ] );
link2.add( colors2[ count ] );
}

link.addAll( link2 ); // concatena lista
link2 = null; // release resources

imprimeLista( link );

uppercaseStrings( link );

imprimeLista( link );

JOptionPane.showMessageDialog( null, “Deletando elementos de 4 a 6…”, “Lista”, JOptionPane.INFORMATION_MESSAGE );

removeItems( link, 4, 7 );

imprimeLista( link );
}

// saida conteudo List
public void imprimeLista( List list )
{

String var = “”;
var = “lista: \n\r” ;

for ( int count = 0; count < list.size(); count++ ){
var += list.get( count ) + “\n\r”;
}

JOptionPane.showMessageDialog( null, var, “Lista”, JOptionPane.INFORMATION_MESSAGE );
}

// objeto String local e converte para uppercase
public void uppercaseStrings( List list )
{
ListIterator iterator = list.listIterator();

while ( iterator.hasNext() ) {
Object object = iterator.next(); // get item

if ( object instanceof String ) // check for String
iterator.set(
( ( String ) object ).toUpperCase() );
}
}

// obtem sublista e usa metodo clear para deletar od itens
public void removeItems( List list, int start, int end )
{
list.subList( start, end ).clear(); // remove items
}

// executa aplicação
public static void main( String args[] )
{
new TesteList();
}

} // fim da classe TesteList]

6. Exemplo HashSet

// Pacotes Java
import java.util.*;
import javax.swing.JOptionPane;

public class TesteSet {
private String colors[] = { “vermelha”, “branca”, “azul”,
“verde”, “cinza”, “laranja”, “bronze”, “branca”, “cinza”,
“pesego”, “ciza”, “laranja” };

// Cria e imprime ArrayList
public TesteSet()
{
ArrayList list;

list = new ArrayList( Arrays.asList( colors ) );
String var = “”;
JOptionPane.showMessageDialog( null, list, “ArrayList”, JOptionPane.INFORMATION_MESSAGE );
imprimeNaoDuplicados( list );
}

// cria um conjunto de array para eleiminar duplicados
public void imprimeNaoDuplicados( Collection collection )
{
// cria um HashSet e obtem iterator
HashSet set = new HashSet( collection );
Iterator iterator = set.iterator();
String var = “Não duplicados: \n\r”;

while ( iterator.hasNext() ){
var += iterator.next() + “\n\r”;

}

JOptionPane.showMessageDialog( null, var, “HashSet”, JOptionPane.INFORMATION_MESSAGE );
}

// executa aplicação
public static void main( String args[] )
{
new TesteSet();
}

} // fim da classe TesteSet

7. Exemplo TreeSet

import java.util.*;
import javax.swing.JOptionPane;

public class TesteOrdenacaoSet {
private static String names[] = { “amarela”, “verde”, “preta”,
“pesego”, “cinza”, “branca”, “laranja”, “vermelha”, “verde” };
private String var = “”;

// cria uma coleção ordenado do TreeSet, e manipula-o
public TesteOrdenacaoSet()
{
TreeSet tree = new TreeSet( Arrays.asList( names ) );
var = “Coleção total \n\r”;

imprimeConjunto( tree );

// pega a base da coleção sobre “laranja”
var = “headSet (\”laranja\”) \n\r”;
imprimeConjunto( tree.headSet( “laranja” ) );

// pega o final da coleção sobre “lararanja”
var = “tailSet (\”laranja\”) \n\r”;
System.out.print( “tailSet (\”laranja\”): ” );
imprimeConjunto( tree.tailSet( “laranja” ) );

// pega o primeiro e o último elemento
var = “primeiro: ” + tree.first() + “\n\r”;
var += “ultimo : ” + tree.last();
JOptionPane.showMessageDialog( null, var, “TreeSet”, JOptionPane.INFORMATION_MESSAGE );
}

// imprime a coleção
public void imprimeConjunto( SortedSet set )
{
Iterator iterator = set.iterator();

while ( iterator.hasNext() ){
var += iterator.next() + “\n\r “;
}

JOptionPane.showMessageDialog( null, var, “TreeSet”, JOptionPane.INFORMATION_MESSAGE );
System.out.println();
}

// executa a aplicação
public static void main( String args[] )
{
new TesteOrdenacaoSet();
}

} // fim da classe TesteOrdenacaoSet

8. Exemplo HashMap

// Pacotes Java
import java.util.*;
import javax.swing.JOptionPane;

public class TesteMap {
private static String names[] = { “um”, “dois”, “tres”,
“quatro”, “cinco”, “seis”, “sete”, “dois”, “dez”, “quatro” };
private String var = “”;

// constroe um HashMap e imprime conteudo
public TesteMap()
{
HashMap map = new HashMap();
Integer i;

for ( int count = 0; count < names.length; count++ ) {
i = ( Integer ) map.get(
new Character( names[ count ].charAt( 0 ) ) );

// se chave não esta no map então é dado um valor e
// do contrário incrementa este valor em 1
if ( i == null )
map.put(
new Character( names[ count ].charAt( 0 ) ),
new Integer( 1 ) );
else
map.put(
new Character( names[ count ].charAt( 0 ) ),
new Integer( i.intValue() + 1 ) );
}

var = “Número de palavras iciadas com cada letra: \n\r”;

imprimetMap( map );
}

// saí­da do conteúdo do map
public void imprimetMap( Map mapRef )
{
var += mapRef.toString() + “\n\r”;
var += “tamanho: ” + mapRef.size() + “\n\r”;
var += “É vazio: ” + mapRef.isEmpty() + “\n\r”;
JOptionPane.showMessageDialog( null, var, “Teste Map”, JOptionPane.INFORMATION_MESSAGE );
}

// executa a aplicação
public static void main( String args[] )
{
new TesteMap();
}

} // fim classe Teste Map

Autores: Carlos Fernando Gonçalves e Marli Esprega Gonçalves (Antares Information Systems)

Retirado de: http://www.javanoroeste.com.br/2006/tutoriais/arrays_colecoes.html

Simulador de Certificações Online

Por Raphael Medeiros, da equipe do jCert.

Está disponível um simulador on-line para certificações Java, o jCert, o sistema esta em fase beta, e no momento sua base de dados esta sendo populada com questões para certificação SCJP, estamos na versão 3 a qual possui suporte a usuários cadastrados e multiplas certificações como: scwcd, etc, a 4 terá acesso através de dispositivos móveis (usando o OperaMini por exemplo) e a versão 5 deverá ganhar o suporte nativo a plataforma Java ME, entre cada uma destas versões melhorias mais simples serão implementadas, o simulador conta também com a ajuda dos usuários os quais podem propor questões ao sistema, as questões serão avaliadas por um Arquiteto Java Certificado e poderão compor a base. Mais informações no site do simulador em:

http://www.jcert.com.br/