Estrutura do 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.

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.

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
                           // element

Basicamente, 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!

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

panthovillas:

for (Object umLapis : s)

[]'s

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?

=]

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?

=]

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:

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
    }        
}

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.

maquiavelbona:

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é!

Lembrando que o compilador de forma alguma deixará voce tentar fazer um cast de um objeto que de nenhuma forma tenha relacionamento de herança.

ClassCastException só serão lançadas caso o objeto de referência seja parente do objeto da instância.

Com a utilização do instanceof voce terá uma maneira segura de saber para qual objeto voce poderá efetuar o cast. Por exemplo:

public class Teste {

    public static void main(String[] args) {

        List listaMaterialEscolar = new ArrayList();
        listaMaterialEscolar.add(new Caderno());
        listaMaterialEscolar.add(new Lapis());
        listaMaterialEscolar.add(new Borracha());

        for (Object item : listaMaterialEscolar) {
            if (item instanceof Lapis) {
                Lapis l = (Lapis) item; // sem problemas; tenho a certeza de que item se refere a um objeto Lapis
                // faca algo com o lapis
            } else if (item instanceof Caderno) {
		
                Caderno c = (Fichario) item; // compila; Fichario É-UM Caderno;		

                c.folhear(); // nenhum problema aqui; a referencia a Caderno enxerga o metodo folhear
                c.adicionarFolhas(1); 	// OPA! problema!; não compila; a variavel de referencia é de um objeto
                                        // Caderno e não Fichario! ou seja Caderno não tem o método adicionarFolhas
                                        // para isso funcionar, o cast deve ser feito na referencia e nao na instancia;
                Fichario f = (Fichario) f;
                f.adicionarFolhas(1); // Aqui sim!!! compila!! e não lança nenhuma exceção		
                Lapis l = (Lapis) item; // compila; porém lança uma ClassCastException em runtime		
            } else if (item instanceof Borracha) {
                // faca algo com a borracha
            } else {
                // algum codigo assustador aqui
            }
        }

    }
}

class Lapis {}

class Caderno {
    public void folhear() { }
}

class Borracha {}

class Fichario
        extends Caderno {
    public void adicionarFolhas(int qtde) {}
}

At.

Só mais uma coisa, a partir do Java 5 já podemo limitar o tipo de objetos que podemos adicionar em uma Collection através da utilização de Generics.

Ex.:

List<Lapis> listaDeLapis = new ArrayList<Lapis>();
listaDeLapis.add(new Lapis()); // isso funciona
listaDeLapis.add(new Caderno()); // isso nao compila, porque a lista esta esperando receber Lapis e nao Caderno

At.