Obter dados de um arrayList

[vieira.jean]

galera to com um problema.
tenho um arraylist que tem varios Jlabels dentro dele.
na hora que do um get preciso pegar o jlabel da posicao x e setar o caption dele.

voce tem ideia de como se faz isso

segue o meu fonte

[code]import java.util.ArrayList;
import java.util.Random;

import javax.swing.JLabel;

import com.sun.org.apache.xalan.internal.xsltc.runtime.Hashtable;

public class teste {
public static String palavraGerada;
public static ArrayList letras;

public static void main(String[] args) {
	Random r = new Random();
	int z = Math.abs(r.nextInt()) % 4;

	String o = Integer.toString(z);

	Hashtable palavras = new Hashtable();
	palavras.put("0", new String("abelha"));
	palavras.put("1", new String("aborrecido"));
	palavras.put("2", new String("abotoadura"));
	palavras.put("3", new String("abreugrafia"));

	palavraGerada = (String) palavras.get(o);
	if (palavraGerada != null) {
		System.out.println(palavraGerada);
		letras = new ArrayList();
		for (int count = 0; count < palavraGerada.length(); count++) {
			 JLabel l = new JLabel("_");
			 letras.add(l);
		}
	}
	String valorDigitado = "a";
	for (int i = 0; i < palavraGerada.length(); i++) {
		if (valorDigitado.equals(String.valueOf(palavraGerada.charAt(i)))) {
			System.out.println(i);
			letras.get(i);

//aqui deveria trocar o caption do jlabel por uma letra que quero.
}
}
}
}
[/code]

[Mantu]

Uma ArrayList, na verdade, guarda apenas objetos Object. Como em java qualquer objeto é um Object, Vc pode entuchar qualquer coisa dentro de um ArrayList. Assim, uma vez que o ArrayList “sabe” apenas que dentro dele tem um monte de Object, se vc pedir pra ele o elemento da posição i, adivinha o que ele vai te dar… um objeto Object… Por isso talvez vc esteja tendo problemas em manipular o suposto JLabel que o ArrayList deveria te retornar através do método get(int).
Vc deve, a grosso modo, fazer um cast no resultado para o tipo JLabel. Algo assim:

JLabel label = (JLabel)letras.get(i);

Mas cuidado!!! Pra fazer isso assim, diretamente, vc tem que ter certeza de que os objetos Object que estão ali dentro do ArrayList letras, principalmente aquele na posição i, são JLabels… Caso não tenha certeza disso, vc pode testar a instancia do elemento retornado pelo get(int):

Object obj = letras.get(i);
if(obj instanceof Object){
	JLabel label = (JLabel)letras.get(i);
	...
}else
	System.out.println("Não era um JLabel o carinha na posição " + i);

Espero que tenha ajudado. Qq dúvida sobre o que foi escrito, pergunto, blz?

[vieira.jean]

vou testar aqui.

valeu pela dica.

uma pergunta,
toda vez que tenho um objeto e quero manipular ele eu dou um cast, ou seja,
tipoobject nome = tipoobject (RetornaObject);

correto.?

[Mantu]

[quote=vieira.jean]
toda vez que tenho um objeto e quero manipular ele eu dou um cast, ou seja,
tipoobject nome = tipoobject (RetornaObject);
correto.?[/quote]
Não é bem assim…
Em java, temos os seguintes conceitos: classe(ou tipo, ou tipo de dados), objeto(ou instância, ou instância de uma classe) e referência.
Uma classe é como se fosse um manual de instruções, que descreve um conceito da vida real(Casa, Carro, Animal, Pessoa, Duplicata, etc.) ou um conceito abstrato(TabelaHash, ListaLigada, Pilha, ListaDuplamenteLigadaComCabeca, etc.).
Um objeto é um representante de uma determinada classe “materializado”, instanciado na memória. Por exemplo, eu e vc, analogamente, seríamos instâncias da classe Humano.
Estes objetos, como foi dito assima, estão materializados, instanciados, alocados em algum local na memória, e é através do endereço deste local que podemos manipular o tal objeto. Só que, na melhor das hipóteses, este endereço é um número hexadecimal (algo como F34AD, por exemplo). Imagine vc programando algo assim:

...
A34D7.D6544(CC434, 1233F);
if(A34D7.EE455(33433) == D344A.EE445(99009))
   return;
...

Vc olharia o seu próprio código e não saberia mais o que representa o A34D7, ou o 33433, ou o D344A... Daí então temos as [b]referências[/b] que servem como "atalhos" para a posição da memória onde está armazenado nosso objeto. Quando declaramos uma [b]variável[/b] de um determinado tipo, estamos criando uma referência para um objeto alocado em memória.

Continua…

[Mantu]

Continuando…

Mas uma referência não é somente um atalho para uma posição de memória... Ela guarda algumas outras informações, conforme a linguagem a que ela pertence. No nosso caso, uma referência Java, se não me engano, tem 3 informações principais:[b]Conteúdo[/b], [b]Tipo[/b] e [b]Identidade[/b]
Vamos dar uma olhada na seguinte linha de código: 

[color=blue]Date[/color] [color=gray]data[/color] = [color=red]new Date()[/color];
No momento em que o compilador lê a instrução acima, é armazenada na memória uma estrutura de dados que tem:
-Conteudo:No nosso exemplo, uma [color=red]instância de Date[/color]. É armazenado aqui um objeto que encapsula os campos e métodos descritos pela classe Date, que consiste exatamente na instanciação do objeto.
-Tipo: Armazena o tipo de dado que foi declarado para a criação da referência. Neste caso o [color=blue]Date[/color].
-Identidade: Armazena o nome da referência que será “ligada” ao objeto armazenado no “Conteúdo” e ao tipo de dado armazenado no “Tipo”. Neste caso a identidade é o [color=gray]data[/color].
Podemos assim encarar as referências como se fossem ponteiros que apontam (Urgh…) para uma posição na memória identificada por uma [color=gray]“identidade”[/color], que tem como [color=red]“conteúdo”[/color] um dado (objeto ou valor unidimensional) compatível com um determinado [color=blue]“tipo”[/color].
Vejamos um exemplo: A classe JLabel extends a classe Object, isso quer dizer que a classe JLabel vai “trazer”(herdar) para si tudo(métodos e campos) que for de acesso público ou protegido ou de pacote(se as duas classes estiverem no mesmo pacote, o que não é o caso) em Object. Podemos dizer assim que uma instância de JLabel é um Object, isto porque tal objeto vai ter, no mínimo, tudo que tem de acessível em Object.
Bom, já que um JLabel é, também, um Object, podemos fazer o seguinte:

Object obj = new JLabel("10");

Sim, pois um objeto JLabel(nesse caso, new JLabel("10")) pode muito bem ser tratado como um representante da classe Object, assim como eu, que sou um Humano(pelo menos minha mãe jura que sou...), sou também um representante da classe SeresVivos...
Temos então em obj, que é uma referência do tipo Object, um conteúdo que é uma instância da classe JLabel. Nós sabemos disso porque [b]nós é que escrevemos o código[/b], mas o computador meio que "não sabe" que ali dentro de obj tem um objeto JLabel... ele sabe, mas [b]nós[/b] mandamos ele tratar o obj como um Object. Em outras palavras, a partir da referência obj, o computador só vai nos deixar acessar "as coisas" de Object, embora lá dentro tenhamos um objeto JLabel.
Então quer dizer que eu perdi meu (objeto)JLabel??? Não! Só que pra recuperá-lo vc vai ter que fazer um [b]cast[/b]...
O cast é quando pedimos para o computador "converter" um tipo em outro tipo [b]compatível[/b]. Foi o que eu disse pra vc fazer quando coloquei meu primeiro post aqui no seu tópico. Existem dois tipos de cast: [b]Upcast[/b] e [b]Downcast[/b].

Continua…

[Mantu]

Finalizando (HAAAAAAA-LE-LU-JA!!!)…

Upcasting: Ocorre quando uma referência de um tipo genérico recebe um objeto de uma de suas subclasses. Isto é sempre permitido, uma vez que temos uma relação do tipo é-um entre classes filha e pai (uma classe filha é uma classe pai, pois traz consigo todos os atributos e métodos do pai. Por exemplo, Quadrado poderia ser uma subclasse de Retangulo).

Retangulo r = new Quadrado();

Em um upcasting, existe a garantia de que a subclasse tem, no mínimo, todos os métodos que a classe genérica tem. Porém, a referência que recebeu em si uma instância de uma subclasse, só poderá acessar a parte comum entre “pai” e “filha”.
.
Downcasting: Caminho inverso do upcasting, o downcasting ocorre quando se tenta “jogar” uma referência de tipo genérico (referência genérica) em uma referência de tipo específico (referência específica), algo como tentar dizer, por exemplo, que um quadrado é apenas um retângulo (O que não é verdade, pois sabemos que um quadrado é um retângulo, só que com a característica adicional de ter todos seus lados iguais). O downcasting deve ser utilizado (Sim! Às vezes precisamos utilizá-lo) com muita cautela, observando algumas peculiaridades. Primeiro, não se pode atribuir explicitamente uma referência genérica a uma referência específica, como feito abaixo:

Quadrado q = r;

Java exige que se faça o cast (conversão de tipos) da referência genérica para a classe apropriada:

Quadrado q = (Quadrado) r;

Este foi um primeiro ponto. Um segundo ponto é conseqüência do primiero: E se r estiver apontando para um Trapezio, por exemplo? Como saber que r realmente aponta para um Quadrado? Simples: utiliza-se o operador instanceof, que opera uma referência à sua esquerda e o nome de uma classe à sua direita. Assim, podemos descobrir se r é uma instância de Quadrado.

If(r instanceof Quadrado) Quadrado q = (quadrado) r;

Se por acaso não for feito este teste, e r aponte para um objeto de tipo incompatível com o tipo Quadrado, Java lançará em tempo de execução uma exceção chamada ClassCastException.
.
Resumindo para o seu caso, o método get(i) do seu ArrayList letras nos retorna um Object. Vc teria que fazer o downcasting dele para um JLabel e então trabalhar com a referência de JLabel que recebeu o downcast.

Afff… Espero (mesmo) ter ajudado e, principalmente, não ter escrito alguma bobagem (Se o fiz, por favor, me corrijam!!!)!