1º modo:

class CopiandoArrays1 {
public static void main(String args[]){
String cor[] = {"vermelho", "azul", "preto", "branco", "rosa"};
String copiaCor[] = (String[]) cor.clone(); //metodo clone da classe Object
for(int i = 0; i < copiaCor.length; i++){
System.out.println(copiaCor[i]);
}
}
}

2º modo:

class CopiandoArrays2 {
public static void main(String args[]){
String cor[] = {"vermelho", "azul", "preto", "branco", "rosa"};
String copiaCor[] = new String[cor.length];
System.arraycopy(cor, 0, copiaCor, 0, cor.length); //Copiando usando o metodo System.arraycopy
for(int i = 0; i < copiaCor.length; i++){
System.out.println(copiaCor[i]);
}
}
}

3º modo:

import java.util.Arrays;
class CopiandoArrays3 {
public static void main(String args[]){
String cor[] = {"vermelho", "azul", "preto", "branco", "rosa"};
String copiaCor[] = new String[cor.length];
for(int indice = 0; indice < cor.length; indice++) {
copiaCor[indice] = cor[indice];
System.out.println(copiaCor[indice]);
}
}
}

Creio que um dos 3 modos ira servir para voce.

Abraços

Primeiro importo a classe Arrays porque é atraves do metodo binarySearch que saberemos se determinada coisa(string, int, double) contem no array. Caso conter, sera retornado o numero do indice que contem essa coisa, como no exemplo acima, que contem a string preto… sera retornado o indice 2. Caso nao conter, sera retornado -1.

Case-sensitive
import java.util.Arrays;
class OrdenarArray1 {
public static void main(String args[]){
String[] cor = {"preto", "Branco", "vermelho", "azul", "Rosa"};
Arrays.sort(cor);
System.out.println(Arrays.toString(cor));
}
}

Resultado na tela é: [Branco, Rosa, azul, preto, vermelho]

Case-insensitive
import java.util.Arrays;
class OrdenarArray2 {
public static void main(String args[]){
String[] cor = {"preto", "Branco", "vermelho", "azul", "Rosa"};
Arrays.sort(cor, String.CASE_INSENSITIVE_ORDER);
System.out.println(Arrays.toString(cor));
}
}

Resultado na tela é: [azul, Branco, preto, Rosa, vermelho]

Case sensitive – Reverse Order
import java.util.Arrays;
import java.util.Collections;
class OrdenarArray3 {
public static void main(String args[]){
String[] cor = {"preto", "Branco", "vermelho", "azul", "Rosa"};
Arrays.sort(cor, Collections.reverseOrder());
System.out.println(Arrays.toString(cor));
}
}

Reparem o uso da classe Collections.

Resultado na tela é: [vermelho, preto, azul, Rosa, Branco]

Case insensitive – Reverse Order
import java.util.Arrays;
import java.util.Collections;
class OrdenarArray4 {
public static void main(String args[]){
String[] cor = {"preto", "Branco", "vermelho", "azul", "Rosa"};
Arrays.sort(cor, String.CASE_INSENSITIVE_ORDER);
Collections.reverse(Arrays.asList(cor));
System.out.println(Arrays.toString(cor));
}
}

Resultado na tela é: [vermelho, Rosa, preto, Branco, azul]

Numeros Inteiros
import java.util.Arrays;
class OrdenarArray5 {
public static void main(String args[]){
int[] cor = {5, 3, -15, 0, -33, 7, -3};
Arrays.sort(cor);
System.out.println(Arrays.toString(cor));
}
}

Resultado na tela é: [-33, -15, -3, 0, 3, 5, 7]

Espero que isso sirva de ajuda para voces.

Abraços

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

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

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/
]]> http://javeiros.wordpress.com/2008/06/25/simulador-de-certificacoes-online/feed/ 0 javeiros http://javeiros.wordpress.com/2008/06/25/evite-float-e-double-se-voce-quer-respostas-exatas/ http://javeiros.wordpress.com/2008/06/25/evite-float-e-double-se-voce-quer-respostas-exatas/#comments Wed, 25 Jun 2008 06:49:34 +0000 javeiros http://javeiros.wordpress.com/?p=3 ]]> por:

David Pereira (david@jeebrasil.com.br)

Usar double ou float podem trazer muitos problemas para operações que exijam exatidão, como operações financeiras. Saiba como evitar tais problemas utilizando as alternativas aqui apresentadas.

Introdução

Um livro que todo programador Java deveria ler é o Effective Java [1], de Joshua Bloch. Effective Java apresenta um conjunto de boas práticas que você deve ter em mente quando está programando em Java e muitas das dicas que o livro dá são preciosas.

Um tópico abordado que eu considero extremamente importante é o que dá título a este artigo: Avoid float and double if exact answers are required, do capítulo 7 – General Programming. Basicamente, o problema é que quando precisamos usar números decimais e precisamos obter respostas exatas, sem erros de precisão, usar os tipos float e double para representar tais números pode causar problemas. Que problemas?

Pegando emprestado o exemplo do Effective Java, imagine que você tem R$ 1,95 no seu bolso e gasta R$ 1,03. Com quanto você vai ficar? A resposta é óbvia: R$ 0,92. Agora tente executar a seguinte linha de código:

System.out.println(1.95 - 1.03);

Listagem 1: Exemplo de operação com doubles que resulta em número inexato

O que será impresso? Não, não será 0,92, será 0,9199999999999999.

Para ilustrar melhor o problema, veja também o seguinte exemplo: você tem R$ 1,50 e quer comprar balas no Mercadinho do Seu Zé. A máquina de balas do Seu Zé funciona da seguinte maneira: você coloca o dinheiro e aperta um botão referente ao tipo de bala que você quer. Cada vez que você aperta um botão, a bala escolhida é expelida pela máquina e o seu saldo é diminuído. Você poderá tirar balas enquanto o seu saldo for maior que zero.

Só que os programadores da máquina de balas do Mercadinho do Seu Zé não foram muito espertos e usaram double para representar o saldo do cliente e os preços das balas. O que acontecerá se você resolver tirar balas de R$ 0,15 até acabar o seu saldo? Quantas balas será possível obter? Uma mente sã responderia 10 balas, mas não é isso que acontece, basta rodar o código abaixo.

double seuSaldo = 1.50;
int balasRetiradas = 0;

while (seuSaldo > 0) {
	balasRetiradas++;
	seuSaldo -= 0.15;
	System.out.println("Retirou " + balasRetiradas + " bala(s)");
	System.out.println("Saldo Atual: " + seuSaldo + "\n");
}

System.out.println("Você retirou " + balasRetiradas + " balas!");

Listagem 2: Algoritmo da máquina de balas do Seu Zé

A saída será a seguinte:

Retirou 1 bala(s)
Saldo Atual: 1.35

Retirou 2 bala(s)
Saldo Atual: 1.2000000000000002

Retirou 3 bala(s)
Saldo Atual: 1.0500000000000003

Retirou 4 bala(s)
Saldo Atual: 0.9000000000000002

Retirou 5 bala(s)
Saldo Atual: 0.7500000000000002

Retirou 6 bala(s)
Saldo Atual: 0.6000000000000002

Retirou 7 bala(s)
Saldo Atual: 0.4500000000000002

Retirou 8 bala(s)
Saldo Atual: 0.30000000000000016

Retirou 9 bala(s)
Saldo Atual: 0.15000000000000016

Retirou 10 bala(s)
Saldo Atual: 1.6653345369377348E-16

Retirou 11 bala(s)
Saldo Atual: -0.14999999999999983

Você retirou 11 balas!

Listagem 3: Como enganar o Seu Zé…

Por causa dos erros de precisão, o seu saldo não era zero quando deveria ser. Era um número bastante pequeno, bem próximo de zero, mas ainda maior que zero. Isso possibilitou a retirada de mais uma bala, até que o saldo ficou negativo – coisa que nunca deveria ocorrer.

Sistemas que lidam com operações monetárias são especialmente sensíveis ao problema apresentado. Erros que, a princípio, poderiam ser desconsiderados, pois representavam apenas 0,0001 centavo, podem virar erros sérios (de algumas dezenas de centavos – que podem não parecer tão importantes mas são essenciais para uma auditoria) quando o montante com o qual se está trabalhando é grande.

Agora que já conhecemos bem o problema, por que isso ocorre? Para entender, vamos usar um pouco de matemática.

Matemática Binária

Nós usamos no dia-a-dia números na base decimal, ou seja, números representados por algarismos que variam de 0 a 9. Além disso, a posição em que esses algarismos se encontram influencia no seu valor – por exemplo, em 25, o algarismo 5 vale 5, mas em 51 o algarismo 5 vale 50. O número 2546, por exemplo, pode ser decomposto de acordo com o valor de cada algarismo em sua posição:

(2 * 1000) + (5 * 100) + (4 * 10) + (6 * 1)

ou ainda:

(2 * 10³) + (5 * 10²) + (4 * 10¹) + (6 * 10⁰)

Podemos considerar então que, começando do zero e crescendo para a esquerda, o valor do algarismo é igual ao seu valor multiplicado por dez elevado à sua posição no número e o valor do número é igual à soma dos valores dos algarismos. Para números decimais, as posições dos números após a vírgula são consideradas negativas, portanto 0,567 é igual a:

(0 * 10⁰) + (5 * 10^-1) + (6 * 10^-2) + (7 * 10^-3)

Já os computadores trabalham com números na base binária: apenas dois algarismos são usados para representar os números – 0 e 1. Na base binária a posição dos algarismos também é importante: no número binário 100, o 1 vale 4. A regra é parecida com a dos números decimais, por exemplo, o número 11001 é igual a:

(1 * 2⁴) + (1 * 2³) + (0 * 2²) + (0 * 2¹) + (1 * 2⁰)

ou seja, 11001 em binário é 25 em decimal. Perceba que não usamos agora o dez como base da exponenciação que determina o valor da posição do algarismo, e sim 2. Se estivéssemos trabalhando com números octais (base 8), usaríamos algarismos de 0 a 7 e base 8 na exponenciação, se estivéssemos trabalhando com base hexadecimal (base 16), usaríamos algarismos de 0 a 9 e as letras A, B, C, D, E e F e base 16 na exponenciação. Para saber mais detalhes sobre números binários, visite os artigos Binary numeral system e Positional notation, na Wikipedia.

Voltando ao problema, os erros de precisão ocorrem porque a representação em binário de alguns números decimais exigem uma quantidade de dígitos maior que a quantidade disponível para armazenamento (a máquina virtual Java aloca 4 bytes – 32 bits – para floats e 8 bytes – 64 bits – para doubles), então teríamos que truncar esses dígitos em algum ponto, consequentemente interferindo na precisão do número.

Considere o algoritmo abaixo para converter um número decimal entre zero e um da base 10 para a base 2:

imprima "0,"
enquanto numero != 0 faça
	numero = numero * 2

	se numero < 1
		imprima "0"
 	senão
		imprima "1"
		numero = numero - 1
	fim
fim

Listagem 4: Algoritmo para conversão decimal para binário de números entre 0 e 1

Tente executá-lo para um número como 0,1, por exemplo:

Listagem 5: Passos do algoritmo da listagem 4 para o número 0.1

Você perceberá que entrará em um loop infinito, pois 0,1 em binário é 0.00011001100110011…

A forma como os computadores armazenam o número não é exatamente essa, mas com isso é possível se ter uma idéia dos problemas decorrentes da representação em binário de números em ponto flutuante. Sugiro que leiam o artigo What every computer scientist should know about floating-point arithmetic [2], de David Goldberd, para entender todos os detalhes deste problema.
3. E agora, como resolver?

O Effective Java sugere que se use int, long ou BigDecimal para representar os valores monetários. A classe BigDecimal foi desenvolvida para resolver dois tipos de problemas associados a números de ponto flutuante (floats e doubles): primeiro, resolve o problema da inexatidão da representação de números decimais; segundo, pode ser usado para trabalhar com números com mais de 16 dígitos significativos. Em compensação, utilizar BigDecimal pode tornar o programa menos legível por não haver sobrecarga dos operadores matemáticos para ela, sendo necessário usar métodos da classe. Veja, por exemplo, como você faria o programa da listagem 1 com BigDecimal:

BigDecimal d1 = new BigDecimal(“1.95″);
BigDecimal d2 = new BigDecimal(“1.03″);

System.out.println(d1.subtract(d2));

Listagem 6: Programa da listagem 1 com BigDecimal

o resultado, ao contrário do primeiro exemplo, é 0.92, ou seja, o valor correto.

Utilizar os primitivos normalmente é mais rápido e mais prático, mas o problema fica por conta da definição das casas decimais. Você pode controlar diretamente as casas decimais, por exemplo, utilizando como unidade para os valores o centavo ao invés de real. Um int ou um long passariam a representar a quantidade de centavos presentes no valor, e não a quatidade de reais. Por exemplo:

long l1 = 195;
long l2 = 103;

System.out.println(l1 – l2);

Listagem 6: Programa da listagem 1 com long

As variáveis acima dizem que você tem 195 centavos (e não R$ 1,95) e vai gastar 103 centavos, e não R$ 1,03. No final você ficará com 92 centavos (e não R$ 0,92).

Se você trabalha com valores com diferentes números de casas decimais, talvez seja melhor deixar o computador fazer este trabalho e utilizar o BigDecimal. Senão, talvez usar long ou int seja mais fácil. Se os valores não ultrapassarem nove dígitos, você pode usar int; até dezoito dígitos, utilize long; e acima disto será necessário usar o BigDecimal.

Veja como ficaria o programa da máquina do Seu Zé com BigDecimal:

BigDecimal seuSaldo = new BigDecimal(“1.50″);
int balasRetiradas = 0;

while (seuSaldo.compareTo(BigDecimal.ZERO) > 0) {
balasRetiradas++;
seuSaldo = seuSaldo.subtract(new BigDecimal(“0.15″));
System.out.println(“Retirou ” + balasRetiradas + ” bala(s)”);
System.out.println(“Saldo Atual: ” + seuSaldo + “\n”);
}

System.out.println(“Você retirou ” + balasRetiradas + ” balas!”);

Listagem 7: Programa do Seu Zé com BigDecimal

E a saída seria:

Retirou 1 bala(s)
Saldo Atual: 1.35

Retirou 2 bala(s)
Saldo Atual: 1.20

Retirou 3 bala(s)
Saldo Atual: 1.05

Retirou 4 bala(s)
Saldo Atual: 0.90

Retirou 5 bala(s)
Saldo Atual: 0.75

Retirou 6 bala(s)
Saldo Atual: 0.60

Retirou 7 bala(s)
Saldo Atual: 0.45

Retirou 8 bala(s)
Saldo Atual: 0.30

Retirou 9 bala(s)
Saldo Atual: 0.15

Retirou 10 bala(s)
Saldo Atual: 0.00

Você retirou 10 balas!

Listagem 8: Saída do programa anterior

De forma parecida, a versão com long seria:

long seuSaldo = 150;
int balasRetiradas = 0;

while (seuSaldo > 0) {
balasRetiradas++;
seuSaldo -= 15;
System.out.println(“Retirou ” + balasRetiradas + ” bala(s)”);
System.out.println(“Saldo Atual: ” + seuSaldo + “\n”);
}

System.out.println(“Você retirou ” + balasRetiradas + ” balas!”);

Listagem 9: Programa do Seu Zé com long

E a saída:

Retirou 1 bala(s)
Saldo Atual: 135

Retirou 2 bala(s)
Saldo Atual: 120

Retirou 3 bala(s)
Saldo Atual: 105

Retirou 4 bala(s)
Saldo Atual: 90

Retirou 5 bala(s)
Saldo Atual: 75

Retirou 6 bala(s)
Saldo Atual: 60

Retirou 7 bala(s)
Saldo Atual: 45

Retirou 8 bala(s)
Saldo Atual: 30

Retirou 9 bala(s)
Saldo Atual: 15

Retirou 10 bala(s)
Saldo Atual: 0

Você retirou 10 balas!

Listagem 10: Saída do programa anterior
Conclusões

Como pudemos ver nos exemplos mostrados no decorrer do artigo, algumas decisões simples e até óbvias, como usar float ou double para representar números decimais, podem trazer conseqüências sérias para o seu programa se não forem bem pensadas e analisadas. Diferenças imperceptíveis a princípio podem tornar-se grandes dores de cabeça e a mudança da estratégia de armazenamento dos valores após a implantação do sistema pode ser algo bem complicado de se fazer. Para não ter problemas no futuro, não se esqueça: “Evite float e double se você quer respostas exatas”.
Referências

[1] Joshua Bloch, Effective Java Programming Language Guide. Addison-Wesley Professional, 2001.

[2] David Goldberg, What every computer scientist should know about floating-point arithmetic. http://docs.sun.com/source/806-3568/ncg_goldberg.html, acesso em 12 de outubro de 2006.

Retirado de: http://www.jeebrasil.com.br/mostrar/47