tem um tipo de for que não é aquele que estou acustumado a ver que seria for( variavel; condição lógica; variavel incrementada ) ex : for(int i = 0; i<10; i++), o for que busco é algo do tipo
private List<Sprite> provokers = new ArrayList<Sprite>()
for (Sprite provoker : provokers)
{ faça.algumacoisa();
}
alguem sabe aonde posso ler algo que fale sobre esse tipo de for???
Acho que vc está falando do foreach, não eh isso??? Um for que percorra uma série de objetos
isso!!!
sabe donde eu consigo um tutorial em português sobre ele?
vlwww
vixe em português em meio difícil… a maioria das coisas é tudo em inglês…
Estou tentando achar em um livro que eu tenho, e já te passo a sintaxe.
[quote=brunoha]vixe em português em meio difícil… a maioria das coisas é tudo em inglês…
Estou tentando achar em um livro que eu tenho, e já te passo a sintaxe.[/quote]
brigaduuuu!!!
Eu achei isto no livro:
More formally, let’s describe the enhanced for as follows:
for(declaration : expression)The two pieces of the for statement are
declaration - The newly declared block variable, of a type compatible with the elements of the array you are accessing. This variable will be available within the for block, and its value will be the same as the current array element.
expression - This must evaluate to the array you want to loop through. This could be an array variable or a method call that returns an array. The array can be any type: primitives, objects, even arrays of arrays.
Exemplos:
int x;
long x2;
Long [] La = {4L, 5L, 6L};
long [] la = {7L, 8L, 9L};
int [][] twoDee = {{1,2,3}, {4,5,6}, {7,8,9}};
String [] sNums = {"one", "two", "three"};
Animal [] animals = {new Dog(), new Cat()};
// legal 'for' declarations
for(long y : la ) ; // loop thru an array of longs
for(long lp : La); // autoboxing the Long objects
// into longs
for(int[] n : twoDee); // loop thru the array of arrays
for(int n2 : twoDee[2]); // loop thru the 3rd sub-array
for(String s : sNums); // loop thru the array of Strings
for(Object o : sNums); // set an Object reference to
// each String
for(Animal a : animals); // set an Animal reference to each
// elementBasicamente, no declaration, vc declara uma variável que irá conter cada elemento de uma série, e no expression é o conjunto de objetos e/ou array que vc quer percorrer
Bela explicação, osmio!
rsrsrs então valeu pela tradução!!! 
Tava correndo na hora para estudar JPA, então soh copiei/colei, nem traduzi…
Ae jhooon, qualquer dúvida eh soh falar! Ou me add no MSN.
Um forte abraço!
Ele é um aprimoramento. Vou colocar um exemplinho que eu fiz pra eu mesmo entender melhor como o código fica mais “limpinho”.
String[] array = new String[]{"valor1", "valor2", "valor3"};
System.out.println("For \"antigo\" ");
for (int i = 0; i < array.length; i++) {
String str = array[i];
// Agora faça algo com o str
System.out.println(str);
}
System.out.println("For \"novo\" ");
for(String str : array){
// Agora faça algo com o str
System.out.println(str);
}Aquele 2 FORs ali fazem exatamente a mesma coisa. Quanto a desempenho, não sei se muda alguma coisa, mas que o código fica bem mais legível, fica. E evita os ArrayIndexOutOfBoundsExceptions… hehehehe
Verdade! Bem lembrado!
Verdade! Bem lembrado![/quote]
vamos ver então se eu entendi bem!!
dado que:
String[] s = new String[] { "valor1","valor2","valor3"};
for (String str : s) {
System.out.println(str);
}
em for (String str : s) toda vez que s “conter” um “string” então a linha abaixo do for ou bloco será executada, caso contrario não? Neste exemplo sempre haverá um string então sempre o bloco do for será executado. Mas, por exemplo, em uma coleção que eu poderia alocar varios tipos de objetos diferentes de classes diferentes, então o que eu disse faria sentido? Pois se em “s” (supondo que não fosse um array de string e sim uma coleção de varios objetos s = {objetoLapis, objetoCaderno, objetoCasa, objetoFabrica}) o for fosse
for (Lapis umLapis : s) {
System.out.println(umLapis);
} então seria impresso os objetos da lista que são do tipo lapis, sendo assim, somente o primeiro!?
Correto? Foi isso que eu entendi… ou está errado?
obrigado!
Caraca jhoon… pra quem não entendia do foreach, uma bela dúvida: não faço a menor idéia… hehehe
Acho que é algo a ser testado…
[EDIT]
Fiz um teste aqui, e nem compilou. Essa estrutura:
for (Lapis umLapis : s) {
System.out.println(umLapis);
} só serve se o Array s for só de objetos Lapis
for (Object umLapis : s)[]'s
[quote=panthovillas]
for (Object umLapis : s)
[]'s[/quote]
me desculpa a ignorância, mas qual seria a diferença entre o que vc escreveu e o que o osmio escreu?
for (Object item : listaMaterialEscolar) {
if(item instanceof Lapis) {
*
*
*
*
}
for (Object umLapis : s)
*
*
*
*já que umLapis e item são “Object”, então o fato de escrever umLapis e na frent Object daria no mesmo do que Object item e por isso a necessidade de logo apos usar instanceof para saber que tipo de “Object” estamos lidando!!!
ou será que se eu declarar um objeto umLapis do tipo Lapis e usar for (Object umLapis : s)
faria diferença? ai no List s ele compararia o que tem lá dentro com o umLapis e quando o que ta lá dentro for umLapis então faria algo?
=]
[quote=jhooon]
me desculpa a ignorância, mas qual seria a diferença entre o que vc escreveu e o que o osmio escreu?
…
já que umLapis e item são “Object”, então o fato de escrever umLapis e na frent Object daria no mesmo do que Object item e por isso a necessidade de logo apos usar instanceof para saber que tipo de “Object” estamos lidando!!!
ou será que se eu declarar um objeto umLapis do tipo Lapis e usar for (Object umLapis : s)
faria diferença? ai no List s ele compararia o que tem lá dentro com o umLapis e quando o que ta lá dentro for umLapis então faria algo?
=][/quote]
O que vem após o tipo de objeto da iteração não importa, é um nome de variável. Se você declarar antes que umLapis como Lápis e na lista tiver um objeto do tipo Caderno vai ser lançada uma exceção. Na abordagem usando instanceof você se preocupa com o tipo de dado e faz o que quer fazer com cada um ( dentro podes usar um cast e transformar na classe que você quiser e assim acessar métodos e atributos convenientes ). Usando a segunda você não se importa com o tipo pois para você todos são do tipo Object e pronto.
Até!
Ao invés de três componentes, o for aprimorado tem dois.
Estrutura antiga:
String[] array = new String[] { "valor1","valor2","valor3"};
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
Estrutura enhanced for:
String[] array = new String[] { "valor1","valor2","valor3"};
for (String str : array) {
System.out.println(str);
}
As duas partes da instrução enhanced for são:
Declaração
A variável de bloco recém declarada, de um tipo compatível com os elementos do array que você esta acessando. Essa variável estará disponivel dentro do bloco for, e o seu valor será o mesmo que o do elemento atual do array;
Expressão
Esta deve avaliar o array através do qual voce quer fazer o loop. Pode ser uma variavel de array, ou uma chamada a um método que retorne um array. O array pode ser de qualquer tipo primitivo, objeto ou até mesmo um array de array. Também vale para Collections.
At.
Basicamente, uma cópia adaptada e traduzida do que voce detalhou no post acima! 
8)
At.
Cada vez que isso acontecesse, o programador deveria levar um cascudo!!!
:twisted: :twisted:
Nesse caso, voce obteria uma ClassCastException, ja que voce esta tratando, por exemplo, objetos caderno como sendo lápis.
Nesse teu exemplo, vc teria que ter um tratamento addim:
[code]
List listaMaterialEscolar = new ArrayList();
listaMaterialEscolar.add(new Caderno());
listaMaterialEscolar.add(new Lapis());
listaMaterialEscolar.add(new Borracha());
for (Object item : listaMaterialEscolar) {
if(item instanceof Lapis) {
// faca algo com o lapis
} else if (item instanceof Caderno) {
// faca algo com o caderno
} else if (item instanceof Borracha) {
// faca algo com a borracha
} else {
// algum codigo assustador aqui
}
}[/code]
Isso eh claro, se os teus objetos não forem polimorficos.
No caso do polimorfismo, vc podera tratar todos os objetos na lista como sendo a super classe. Porem, só tera acesso aos métodos que são visiveis a tal.
At.