Como o Java "para cada' loop de trabalho?

https://stackoverflow.com/questions/85190

01-07-2019
|

Pergunta

Considere:

List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList

for (String item : someList) {
    System.out.println(item);
}

O que seria o equivalente a for loop parecer sem utilizar o para cada sintaxe?

Solução

for (Iterator<String> i = someIterable.iterator(); i.hasNext();) {
    String item = i.next();
    System.out.println(item);
}

Note que, se você precisa usar i.remove(); em seu loop, ou acesso o iterador real, de alguma forma, você não pode usar o idioma for ( : ), uma vez que o iterador real é meramente inferida.

Como foi referido por Denis Bueno, este código funciona para qualquer objeto que implementa a Iterable interface de .

Além disso, se o lado direito do idioma for (:) é um array em vez de um objecto Iterable, o código interno utiliza um contador do índice int e controlos contra array.length vez. Veja a Java Specification Língua .

Outras dicas

A construção para cada também é válido para matrizes. por exemplo.

String[] fruits = new String[] { "Orange", "Apple", "Pear", "Strawberry" };

for (String fruit : fruits) {
    // fruit is an element of the `fruits` array.
}

que é essencialmente equivalente a

for (int i = 0; i < fruits.length; i++) {
    String fruit = fruits[i];
    // fruit is an element of the `fruits` array.
}

Assim, o resumo geral:
[nsayer] O seguinte é o mais forma do que está acontecendo:

for(Iterator<String> i = someList.iterator(); i.hasNext(); ) {
  String item = i.next();
  System.out.println(item);
}
Note que, se você precisa usar eu removo(); em seu loop, ou acesso o iterador real, de alguma forma, você não pode usar o para: idioma, uma vez que () o Iterator real é meramente inferido.

[Denis Bueno]

Ele está implícito pela resposta de nsayer, mas É importante notar que o OP é para (..) sintaxe funcionará quando "someList" é qualquer coisa que implementa java.lang.Iterable - ele não tem para ser uma lista ou alguma coleção de java.util. Até mesmo seus próprios tipos, portanto, pode ser usado com esta sintaxe.

O foreach loop, adicionado em Java 5 (também chamado de "enhanced for loop"), é equivalente ao uso de um java.util.Iterator- é um açúcar sintático para a mesma coisa.Portanto, quando a leitura de cada elemento, um a um e em ordem, uma foreach deve sempre ser escolhido mais de um iterador, como é mais conveniente e concisa.

foreach

for(int i : intList) {
   System.out.println("An element in the list: " + i);
}

Iterador

Iterator<Integer> intItr = intList.iterator();
while(intItr.hasNext()) {
   System.out.println("An element in the list: " + intItr.next());
}

Existem situações onde você deve usar um Iterator diretamente.Por exemplo, ao tentar excluir um elemento, enquanto usando um foreach pode (será?) resultar em um ConcurrentModificationException.

`foreach` vs. `for`:Diferenças básicas

A única diferença prática entre for e foreach é que, no caso de objetos intercambiáveis, você não tem acesso ao índice.Um exemplo de quando a basic for loop é necessário:

for(int i = 0; i < array.length; i++) {
   if(i < 5) {
      // Do something special
   }  else {
      // Do other stuff
   }
}

Embora você possa criar manualmente um índice separado int-variável com foreach,

int idx = -1;
for(int i : intArray) {
   idx++;
   ...
}

não é recomendável, uma vez que a variável de escopo não é o ideal, e o básico for loop é simplesmente o padrão e o formato esperado para este caso de uso.

`foreach` vs. `for`:Desempenho

Quando acessar coleções, uma foreach é significativamente mais rápido que o básico for ciclo da matriz de acesso.Ao acessar matrizes, porém-pelo menos com o primitivo e o wrapper-matrizes--acesso através de índices é consideravelmente mais rápido.

Temporização a diferença entre iterador e índice de acesso para o primitivo int-matrizes

Os índices são 23-40 por cento mais rápido do que os iteradores ao acessar int ou Integer matrizes.Aqui está o resultado do teste de classe, no fundo deste post, que soma os números de 100-elemento primitivo-int array (Um iterador é, B é o índice):

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 358,597,622 nanoseconds
Test B: 269,167,681 nanoseconds
B faster by 89,429,941 nanoseconds (24.438799231635727% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 377,461,823 nanoseconds
Test B: 278,694,271 nanoseconds
B faster by 98,767,552 nanoseconds (25.666236154695838% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 288,953,495 nanoseconds
Test B: 207,050,523 nanoseconds
B faster by 81,902,972 nanoseconds (27.844689860906513% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,373,765 nanoseconds
Test B: 283,813,875 nanoseconds
B faster by 91,559,890 nanoseconds (23.891659337194227% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,790,818 nanoseconds
Test B: 220,770,915 nanoseconds
B faster by 155,019,903 nanoseconds (40.75164734599769% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 326,373,762 nanoseconds
Test B: 202,555,566 nanoseconds
B faster by 123,818,196 nanoseconds (37.437545972215744% faster)

Eu também corri para uma Integer matriz, e os índices são ainda o vencedor claro, mas só entre os 18 e os 25% mais rápido.

Para as coleções, os iteradores são mais rápidos do que os índices de

Para um List de Integers, no entanto , os iteradores são o claro vencedor.Basta alterar o int-matriz do teste de classe:

List<Integer> intList = Arrays.asList(new Integer[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100});

E fazer as alterações necessárias para o teste de função (int[] para List<Integer>, length para size(), etc.):

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,429,929,976 nanoseconds
Test B: 5,262,782,488 nanoseconds
A faster by 1,832,852,512 nanoseconds (34.326681820485675% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,907,391,427 nanoseconds
Test B: 3,957,718,459 nanoseconds
A faster by 1,050,327,032 nanoseconds (26.038700083921256% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,566,004,688 nanoseconds
Test B: 4,221,746,521 nanoseconds
A faster by 1,655,741,833 nanoseconds (38.71935684115413% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,770,945,276 nanoseconds
Test B: 3,829,077,158 nanoseconds
A faster by 1,058,131,882 nanoseconds (27.134122749113843% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,467,474,055 nanoseconds
Test B: 5,183,149,104 nanoseconds
A faster by 1,715,675,049 nanoseconds (32.60101667104192% faster)

[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,439,983,933 nanoseconds
Test B: 3,509,530,312 nanoseconds
A faster by 69,546,379 nanoseconds (1.4816434912159906% faster)

[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,451,101,466 nanoseconds
Test B: 5,057,979,210 nanoseconds
A faster by 1,606,877,744 nanoseconds (31.269164666060377% faster)

Em um teste que eles são quase equivalentes, mas com coleções, o iterador de vitórias.

*Este post é baseado em duas respostas que eu escrevi no Estouro de Pilha:

Mais algumas informações: O que é mais eficiente, um de cada ciclo, ou um iterador?

O teste completo da classe

Eu criei este compare-o-tempo-que-leva-para-fazer-qualquer-duas-coisas de classe depois de ler esta pergunta no Estouro de Pilha:

import  java.text.NumberFormat;
import  java.util.Locale;

/**
   &lt;P&gt;{@code java TimeIteratorVsIndexIntArray 1000000}&lt;/P&gt;

   @see  &lt;CODE&gt;&lt;A HREF=&quot;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&quot;&gt;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&lt;/A&gt;&lt;/CODE&gt;
 **/
public class TimeIteratorVsIndexIntArray {

    public static final NumberFormat nf = NumberFormat.getNumberInstance(Locale.US);

    public static final void main(String[] tryCount_inParamIdx0) {
        int testCount;

        // Get try-count from a command-line parameter
        try {
           testCount = Integer.parseInt(tryCount_inParamIdx0[0]);
        }
        catch(ArrayIndexOutOfBoundsException | NumberFormatException x) {
           throw  new IllegalArgumentException("Missing or invalid command line parameter: The number of testCount for each test. " + x);
        }

        //Test proper...START
        int[] intArray = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100};

        long lStart = System.nanoTime();
        for(int i = 0; i < testCount; i++) {
           testIterator(intArray);
        }

        long lADuration = outputGetNanoDuration("A", lStart);

        lStart = System.nanoTime();
        for(int i = 0; i < testCount; i++) {
           testFor(intArray);
        }

        long lBDuration = outputGetNanoDuration("B", lStart);

        outputGetABTestNanoDifference(lADuration, lBDuration, "A", "B");
    }

    private static final void testIterator(int[] int_array) {
       int total = 0;
       for(int i = 0; i < int_array.length; i++) {
          total += int_array[i];
       }
    }

    private static final void testFor(int[] int_array) {
       int total = 0;
       for(int i : int_array) {
          total += i;
       }
    }
    //Test proper...END

    //Timer testing utilities...START
    public static final long outputGetNanoDuration(String s_testName, long l_nanoStart) {
        long lDuration = System.nanoTime() - l_nanoStart;
        System.out.println("Test " + s_testName + ": " + nf.format(lDuration) + " nanoseconds");
        return  lDuration;
    }

    public static final long outputGetABTestNanoDifference(long l_aDuration, long l_bDuration, String s_aTestName, String s_bTestName) {
        long lDiff = -1;
        double dPct = -1.0;
        String sFaster = null;
        if(l_aDuration > l_bDuration) {
            lDiff = l_aDuration - l_bDuration;
            dPct = 100.00 - (l_bDuration * 100.0 / l_aDuration + 0.5);
            sFaster = "B";
        }
        else {
            lDiff = l_bDuration - l_aDuration;
            dPct = 100.00 - (l_aDuration * 100.0 / l_bDuration + 0.5);
            sFaster = "A";
        }
        System.out.println(sFaster + " faster by " + nf.format(lDiff) + " nanoseconds (" + dPct + "% faster)");
        return  lDiff;
   }

   //Timer testing utilities...END

}

Aqui está uma resposta que não assume conhecimento de Java Iterators. É menos preciso, mas é útil para a educação.

Enquanto a programação que código frequentemente gravação que parece com o seguinte:

char[] grades = ....
for(int i = 0; i < grades.length; i++) {   // for i goes from 0 to grades.length
    System.out.print(grades[i]);           // Print grades[i]
}

A sintaxe foreach permite que este padrão comum a ser escrito de uma forma mais natural e menos sintaticamente barulhento.

for(char grade : grades) {   // foreach grade in grades
    System.out.print(grade); // print that grade
}

Além disso, esse sintaxe é válida para objetos, como listas ou conjuntos que não suportam a indexação de matriz, mas que fazer implementar a interface Java Iterable.

O para-cada loop em Java usa o mecanismo iterador subjacente. Portanto, é idêntico ao seguinte:

Iterator<String> iterator = someList.iterator();

while (iterator.hasNext()) {
  String item = iterator.next();
  System.out.println(item);
}

Em Java 8 características que você pode usar este:

List<String> messages = Arrays.asList("First", "Second", "Third");

void forTest(){
    messages.forEach(System.out::println);
}

saída

First
Second
Third

Ele está implícito pela resposta de nsayer, mas é interessante notar que o OP é para (..) sintaxe funcionará quando "someList" é qualquer que implementa java.lang.Iterable - isso não acontece tem que ser uma lista ou alguma coleção de java.util. Até mesmo seus próprios tipos, portanto, pode ser utilizado com esta sintaxe.

A sintaxe de loop foreach é:

for (type obj:array) {...}

Exemplo:

String[] s = {"Java", "Coffe", "Is", "Cool"};
for (String str:s /*s is the array*/) {
    System.out.println(str);
}

Output:

Java
Coffe
Is
Cool

AVISO: Você pode acessar os elementos de matriz com o loop foreach, mas você não pode inicializar-los. Use o loop for original para isso.

AVISO:. Você deve corresponder ao tipo da matriz com o outro objeto

for (double b:s) // Invalid-double is not String

Se você quiser editar elementos, use o loop for original, como este:

for (int i = 0; i < s.length-1 /*-1 because of the 0 index */; i++) {
    if (i==1) //1 because once again I say the 0 index
        s[i]="2 is cool";
    else
        s[i] = "hello";
}

Agora, se nós despejar s para o console, obtemos:

hello
2 is cool
hello
hello

Como definido na JLS para -Cada circuito pode ter duas formas:

Se o tipo de expressão é um subtipo de Iterable seguida, a tradução é como:

List<String> someList = new ArrayList<String>();
someList.add("Apple");
someList.add("Ball");
for (String item : someList) {
    System.out.println(item);
}

// IS TRANSLATED TO:

for(Iterator<String> stringIterator = someList.iterator(); stringIterator.hasNext(); ) {
    String item = stringIterator.next();
    System.out.println(item);
}

Se a expressão tem necessariamente um tipo de matriz T[] então:

String[] someArray = new String[2];
someArray[0] = "Apple";
someArray[1] = "Ball";

for(String item2 : someArray) {
    System.out.println(item2);
}

// IS TRANSLATED TO:
for (int i = 0; i < someArray.length; i++) {
    String item2 = someArray[i];
    System.out.println(item2);
}

Java 8 introduziu fluxos que executam geralmente melhor. Podemos usá-los como:

someList.stream().forEach(System.out::println);
Arrays.stream(someArray).forEach(System.out::println);

O Java "for-each" construção de loop permitirá iteração sobre dois tipos de objetos:

T[] (matrizes de qualquer tipo)
java.lang.Iterable<T>

A interface Iterable<T> tem apenas um método: Iterator<T> iterator(). Isso funciona em objetos do tipo Collection<T> porque a interface Collection<T> estende Iterable<T>.

O conceito de um loop foreach como mencionado na Wikipedia é destacado abaixo:

Ao contrário de outros para construções de laço, no entanto, geralmente loops foreach manter não contra explícita : eles basicamente dizer "faça isso tudo neste jogo", ao invés de 'fazer isso x vezes'. Isso evita potencial off-by-one erros e torna o código mais fácil de ler.

Assim, o conceito de um loop foreach descreve que o loop não usar qualquer balcão explícito o que significa que não há necessidade de usar índices para atravessar na lista, assim ele economiza usuário de off-by-one erro. Para descrever o conceito geral deste erro off-por-um, vamos dar um exemplo de um loop para percorrer em uma lista usando índices.

// In this loop it is assumed that the list starts with index 0 for(int i=0; i<list.length; i++){ }

Mas suponha que se a lista começa com índice 1, então este ciclo vai lançar uma exceção como ele irá encontrado nenhum elemento no índice 0 e este erro é chamado um erro off-por-um. Então, para evitar esse erro off-por-um o conceito de um loop foreach é usado. Pode haver outras vantagens também, mas isso é o que eu acho que é o conceito principal e vantagem de usar um loop foreach.

for (Iterator<String> itr = someList.iterator(); itr.hasNext(); ) { String item = itr.next(); System.out.println(item); }

Aqui está uma expressão equivalente.

for(Iterator<String> sit = someList.iterator(); sit.hasNext(); ) { System.out.println(sit.next()); }

Além disso, note que a utilização do método de "foreach" na pergunta original tem algumas limitações, como não ser capaz de remover itens da lista durante a iteração.

O novo loop for é mais fácil de ler e elimina a necessidade de um iterador separado, mas só é realmente utilizável em read-only iteração passa.

Usando versões mais antigas do Java, incluindo Java 7 você pode usar circuito foreach como segue.

List<String> items = new ArrayList<>(); items.add("A"); items.add("B"); items.add("C"); items.add("D"); items.add("E"); for(String item : items){ System.out.println(item); }

A seguir é a mais recente forma de utilização de loop foreach em Java 8

(circular uma lista com forEach + expressão lambda ou método de referência)

//lambda //Output : A,B,C,D,E items.forEach(item->System.out.println(item)); //method reference //Output : A,B,C,D,E items.forEach(System.out::println);

Para obter mais informações, consulte este link.

https://www.mkyong.com/java8/java-8 -foreach-exemplos /

Uma alternativa para forEach, a fim de evitar o seu "para cada":

List<String> someList = new ArrayList<String>();

Variante 1 (normal):

someList.stream().forEach(listItem -> { System.out.println(listItem); });

Variante 2 (execução paralela (mais rápido)):

someList.parallelStream().forEach(listItem -> { System.out.println(listItem); });

Ele acrescenta beleza ao seu código, removendo toda a desordem básica looping. Ele dá uma aparência limpa ao seu código, justifica abaixo.

normal ciclo for:

void cancelAll(Collection<TimerTask> list) { for (Iterator<TimerTask> i = list.iterator(); i.hasNext();) i.next().cancel(); }

Usando for-each:

void cancelAll(Collection<TimerTask> list) { for (TimerTask t : list) t.cancel(); }

para-cada é uma construção através de uma recolha que implementa Repetidor . Lembre-se que, sua coleção deve implementar Iterator ; caso contrário você não pode usá-lo com for-each.

A linha a seguir é lido como " para cada TimerTask t na lista. "

for (TimerTask t : list)

Há menos chance de erros no caso de for-each. Você não tem que se preocupar com a inicializar o iterador ou inicializar o contador de loop e terminá-lo (caso haja margem para erros).

Em Java 8, eles introduziram forEach. Usá-lo List, Mapas pode ser enrolada.

Curva de uma lista usando para cada

List<String> someList = new ArrayList<String>(); someList.add("A"); someList.add("B"); someList.add("C"); someList.forEach(listItem -> System.out.println(listItem))

ou

someList.forEach(listItem-> { System.out.println(listItem); });

Curva um mapa usando para cada

Map<String, String> mapList = new HashMap<>(); mapList.put("Key1", "Value1"); mapList.put("Key2", "Value2"); mapList.put("Key3", "Value3"); mapList.forEach((key,value)->System.out.println("Key: " + key + " Value : " + value));

ou

mapList.forEach((key,value)->{ System.out.println("Key : " + key + " Value : " + value); });

Seria algo parecido com isto. Muito intrincada.

for (Iterator<String> i = someList.iterator(); i.hasNext(); ) System.out.println(i.next());

Há um bom writeup em para cada na Sun documentação .

Antes de Java 8, você precisa usar o seguinte:

Iterator<String> iterator = someList.iterator(); while (iterator.hasNext()) { String item = iterator.next(); System.out.println(item); }

No entanto, com a introdução de Streams em Java 8 você pode fazer mesma coisa em muito sintaxe menos. Por exemplo, para o seu someList você pode fazer:

someList.stream().forEach(System.out::println);

Você pode encontrar mais sobre fluxos aqui .

Como muitas respostas boas disse, um objeto deve implementar a Iterable interface se quiser usar um loop for-each.

Vou postar um exemplo simples e tentar explicar de uma maneira diferente como um laço for-each obras.

O exemplo ciclo for-each:

public class ForEachTest { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("111"); list.add("222"); for (String str : list) { System.out.println(str); } } }

Então, se usarmos javap descompilar esta classe, vamos obter esta amostra bytecode:

public static void main(java.lang.String[]); flags: ACC_PUBLIC, ACC_STATIC Code: stack=2, locals=4, args_size=1 0: new #16 // class java/util/ArrayList 3: dup 4: invokespecial #18 // Method java/util/ArrayList."<init>":()V 7: astore_1 8: aload_1 9: ldc #19 // String 111 11: invokeinterface #21, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z 16: pop 17: aload_1 18: ldc #27 // String 222 20: invokeinterface #21, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z 25: pop 26: aload_1 27: invokeinterface #29, 1 // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;

Como podemos ver a partir da última linha do exemplo, o compilador irá converter automaticamente o uso da palavra-chave for-each para o uso de um Iterator em tempo de compilação. Isso pode explicar por objeto, que não implementa a Iterable interface, irá lançar uma Exception quando ele tenta usar o loop for-each.

public static Boolean Add_Tag(int totalsize) { List<String> fullst = new ArrayList<String>(); for(int k=0;k<totalsize;k++) { fullst.addAll(); } }

O Java para cada loop (aka loop for aprimorado) é um simplificado versão de um loop for. A vantagem é que há menos código para escrever e menos variáveis ??para gerenciar. A desvantagem é que você não tem nenhum controle sobre o valor do passo e sem acesso ao índice de ciclo dentro do corpo do laço.

Eles são mais utilizados quando o valor do passo é um simples incremento de 1 e quando você só precisa de acesso ao elemento de circuito de corrente. Por exemplo, se você precisa de um loop sobre cada elemento em uma matriz ou coleção sem espreitar à frente ou atrás do elemento atual.

Não há nenhuma inicialização de loop, nenhuma condição boolean eo valor passo é implícito e é um incremento simples. É por isso que eles são considerados muito mais simples do que o normal para loops.

aprimorado para loops de seguir esta ordem de execução:

1) corpo do laço

2) repetição do passo 1, até que todo matriz ou recolha tem sido deslocado

Exemplo - Integer matriz

int [] intArray = {1, 3, 5, 7, 9}; for(int currentValue : intArray) { System.out.println(currentValue); }

A variável CurrentValue contém o valor atual que está sendo posto em loop na matriz intArray. Aviso não há nenhum valor explícito passo -. É sempre um incremento de 1

O cólon pode ser pensado para significar “em”. Assim, o avançado para estados declaração de loop:. Loop sobre intArray e armazenar o valor de matriz int atual em a variável CurrentValue

Output:

1 3 5 7 9

Exemplo - corda matriz

Podemos usar a for-each loop para iterar sobre uma matriz de strings. Os estados declaração Loop:. Laço mais variedade myStrings corda e armazenar o valor da cadeia atual em a variável CurrentString

String [] myStrings = { "alpha", "beta", "gamma", "delta" }; for(String currentString : myStrings) { System.out.println(currentString); }

Output:

alpha beta gamma delta

Exemplo - List

O reforçada por laço pode também ser utilizado para repetir um java.util.List como se segue:

List<String> myList = new ArrayList<String>(); myList.add("alpha"); myList.add("beta"); myList.add("gamma"); myList.add("delta"); for(String currentItem : myList) { System.out.println(currentItem); }

Os estados declaração de loop:. Loop sobre myList lista de strings e armazenar o valor atual lista em a variável currentItem

Output:

alpha beta gamma delta

Exemplo - Set

O reforçada por laço pode também ser utilizado para repetir um java.util.Set como se segue:

Set<String> mySet = new HashSet<String>(); mySet.add("alpha"); mySet.add("alpha"); mySet.add("beta"); mySet.add("gamma"); mySet.add("gamma"); mySet.add("delta"); for(String currentItem : mySet) { System.out.println(currentItem); }

Os estados declaração de loop: loop sobre Meumodo Conjunto de Cordas e armazenar o valor atual conjunto em a variável currentItem. Tenha em conta que uma vez que este é um Set, valores duplicados cordas não são armazenados.

Output:

alpha delta beta gamma

Fonte: Loops em Java - Ultimate Guide

O Java for-each expressão só pode ser aplicada a matrizes ou objetos do tipo * Iterable . Esta expressão é implícita como ele realmente apoiado por um Iterator. O Repetidor é programada pelo programador e muitas vezes usa um índice inteiro ou um nó (dependendo da estrutura de dados) para manter o controle da sua posição. No papel, é mais lento do que um loop for regular, a menos de "linear" estruturas como matrizes e listas, mas que proporciona maior abstração.

Isso parece loucura, mas hey ele funciona

List<String> someList = new ArrayList<>(); //has content someList.forEach(System.out::println);

Isso funciona. Mágica

List<Item> Items = obj.getItems(); for(Item item:Items) { System.out.println(item); }

Itera sobre todos os objetos na tabela Items.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow