26 Pregunta: ¿Cómo funciona el bucle Java 'para cada'?

pregunta creada en Fri, Feb 23, 2018 12:00 AM

Considera:

 
List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList
 
for (String item : someList) {
    System.out.println(item);
}

¿Qué aspecto tendría el bucle for equivalente sin utilizar la sintaxis para cada ?

    
1391
  1. Según JLS tiene dos formas: stackoverflow.com/a/33232565 /1216775
    2018-09-24 04: 40: 54Z
26 Respuestas                              26                         
 
for (Iterator<String> i = someIterable.iterator(); i.hasNext();) {
    String item = i.next();
    System.out.println(item);
}

Tenga en cuenta que si necesita usar i.remove(); en su bucle, o acceder al iterador real de alguna manera, no puede usar el idioma for ( : ), ya que el iterador real es simplemente inferido.

Como señaló Denis Bueno, este código funciona para cualquier objeto que implemente Iterable interfaz .

Además, si el lado derecho del lenguaje for (:) es un array en lugar de un objeto Iterable, el código interno usa un contador de índice int y se compara con el array.length. Consulte la Especificación del lenguaje Java .

    
1104
2018-03-03 16: 16: 09Z
  1. He encontrado simplemente llamando a un ciclo while como while (someList.hasMoreElements ()) {//hacer algo}} - obtiene cerca de la gracia de codificación que esperaba encontrar cuando busqué esta pregunta.
    2012-11-16 18: 10: 16Z
  2. También vea docs.oracle.com/javase/1.5.0/docs/guide/language/foreach.html que explica el bucle foreach (cuando se introdujo)
    2014-02-27 16: 12: 24Z
  3. para desarrolladores de Android Studio: import java.util.Iterator; y import java.lang.Iterable;
    2016-05-10 19: 12: 37Z

La construcción para cada también es válida para matrices. por ejemplo

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

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

que es esencialmente equivalente a

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

Entonces, resumen general:
[ nsayer] La siguiente es la forma más larga de lo que está sucediendo:

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

Tenga en cuenta que si necesita usar   yo remuevo(); en su bucle, o acceso   el iterador real de alguna manera, usted   no se puede usar el idioma for (:), ya que   el iterador real es meramente   inferido.

[Denis Bueno]

  

Está implícito en la respuesta de nsayer, pero   Vale la pena señalar que los OP son para (..)   la sintaxis funcionará cuando "someList" es   cualquier cosa que implemente   java.lang.Iterable - no tiene   para ser una lista, o alguna colección de   java.util. Incluso tus propios tipos,   por lo tanto, se puede utilizar con este   sintaxis.

    
469
2018-03-16 13: 06: 59Z

El foreach loop , agregado en Java 5 (también llamado "mejorado para loop "), es equivalente a usar un java.util.Iterator - es el azúcar sintáctica para la misma cosa. Por lo tanto, al leer cada elemento, uno por uno y en orden, siempre se debe elegir un foreach un iterador, ya que es más conveniente y conciso.

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());
}

Hay situaciones en las que debes usar un Iterator directamente. Por ejemplo, intentar eliminar un elemento mientras usa un foreach puede (¿lo hará?) Dar como resultado un ConcurrentModificationException.

 foreach vs. for: diferencias básicas

La única diferencia práctica entre for y foreach es que, en el caso de objetos indexables, no tiene acceso al índice. Un ejemplo cuando se requiere el bucle básico for:

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

Aunque podría crear manualmente una variable int de índice separada con foreach,

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

no se recomienda, ya que variable-scope no es ideal , y el bucle básico for es simplemente el formato estándar y esperado para este caso de uso.

 foreach vs. for: Rendimiento

Al acceder a las colecciones, un foreach es significativamente más rápido que Acceso a la matriz básica del bucle for. Sin embargo, al acceder a matrices, al menos con matrices primitivas y de envoltura, el acceso a través de índices es mucho más rápido.

Sincronización de la diferencia entre el iterador y el acceso al índice para matrices internas primitivas

Los índices son 23- 40 más rápidos que los iteradores al acceder a int o Integer matrices. Aquí está el resultado de la clase de prueba en la parte inferior de esta publicación, que suma los números en una matriz de primitivo-int de 100 elementos (A es iterador, B es í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)

También ejecuté esto para una matriz Integer, y los índices siguen siendo el claro ganador, pero solo entre un 18 y un 25 por ciento más rápido.

Para las colecciones, los iteradores son más rápidos que los índices

Para un List de Integers, sin embargo, los iteradores son el claro ganador. Simplemente cambie el int-array en la clase de prueba a:

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

Y realice los cambios necesarios en la función de prueba (int[] a List<Integer>, length a 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)

En una prueba son casi equivalentes, pero con colecciones, el iterador gana.

* Esta publicación se basa en dos respuestas que escribí en Stack Overflow:

Más información: ¿Cuál es más eficiente, un bucle para cada bucle o un iterador?

La clase de prueba completa

Creé esta clase de comparar el tiempo que se tarda en hacer dos cosas después de leer esta pregunta sobre Desbordamiento de pila:

 
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

}
    
144
2018-03-16 13: 35: 45Z
  1. Esta respuesta es ahora un publicación de blog y se creó a partir de dos respuestas relacionadas que he escrito: aquí y aquí . También incluye una clase genéricamente útil para comparar la velocidad de dos funciones (en la parte inferior).
    2014-04-19 18: 23: 12Z
  2. Solo un comentario menor aquí, no debe indicar categóricamente que para (:) la sintaxis siempre es mejor para acceder a las colecciones; si está utilizando una lista de matrices, el bucle for (:) será aproximadamente 2 veces más lento que el uso de (int i = 0, len = arrayList.size (); i < len; i ++). Creo que mencionaste eso en el [enlace] ( stackoverflow.com/questions/2113216/… ) de todos modos, pero es importante resaltar que ...
    2014-09-26 11: 25: 04Z
  3. @ Leo Es un buen punto. Una ArrayList es una colección, pero está respaldada por una matriz, razón por la cual lo normal es mejor para ella.
    2014-09-26 13: 07: 40Z
  4. Imagino que el for(int value : int_array) {/* loop content */} es más lento en tu prueba porque es sintácticamente equivalente a for(int i = 0; i < int_array.length; i++) {int value = int_array[i]; /* loop content */}, que no es lo que compara tu prueba.
    2015-08-20 08: 53: 08Z
  5. ¡¡Buena explicación !!
    2018-06-25 05: 39: 18Z

Aquí hay una respuesta que no asume el conocimiento de los iteradores de Java. Es menos preciso, pero es útil para la educación.

Mientras programamos, a menudo escribimos un código similar al siguiente:

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

La sintaxis de foreach permite que este patrón común se escriba de una forma más natural y menos sintácticamente ruidosa.

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

Además, esta sintaxis es válida para objetos como listas o conjuntos que no admiten la indexación de matrices, pero que implementan la interfaz de Iterable de Java.

    
126
2018-03-16 13: 12: 45Z

El bucle for-each en Java utiliza el mecanismo de iterador subyacente. Así que es idéntico a lo siguiente:

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

while (iterator.hasNext()) {
  String item = iterator.next();
  System.out.println(item);
}
    
37
2018-03-16 13: 04: 16Z

En las características de Java 8 puedes usar esto:

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

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

Salida

 
First
Second
Third
    
23
2017-09-25 15: 43: 15Z
  1. esta información aleatoria ni siquiera responde la pregunta de forma remota
    2018-02-16 14: 55: 37Z

Está implícito en la respuesta de nsayer, pero vale la pena señalar que la sintaxis de OP (...) funcionará cuando "someList" es cualquier cosa que implemente java.lang.Iterable - no Tiene que ser una lista, o alguna colección de java.util. Incluso sus propios tipos, por lo tanto, pueden usarse con esta sintaxis.

    
23
2018-03-16 13: 05: 36Z
  1. También, por cierto, algunas matrices de objetos mágicos astutos también funcionan.
    2008-09-17 17: 34: 59Z
  2. fd tiene razón: el código interno cuando el lado derecho de la lengua for (:) utiliza un int y array.length en lugar de buscar un Iterator. forums.sun.com/thread.jspa?messageID=2743233
    2008-09-17 17: 54: 54Z

La sintaxis de un bucle foreach es:

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

Ejemplo:

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

Salida:

 
Java
Coffe
Is
Cool

ADVERTENCIA: puede acceder a los elementos de la matriz con el bucle foreach, pero NO puede inicializarlos. Utilice el bucle original for para eso.

ADVERTENCIA: debe hacer coincidir el tipo de la matriz con el otro objeto.

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

Si desea editar elementos, use el bucle 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";
}

Ahora si volcamos s a la consola, obtenemos:

 
hello
2 is cool
hello
hello
    
22
2018-03-16 13: 16: 36Z

Según se define en JLS para -cada bucle puede tener dos formas:

  1. Si el tipo de expresión es un subtipo de Iterable, la traducción es 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);
    }
    
  2. Si la expresión tiene necesariamente un tipo de matriz T[], entonces:

     
    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 ha introducido flujos que generalmente funcionan mejor. Podemos usarlos como:

 
someList.stream().forEach(System.out::println);
Arrays.stream(someArray).forEach(System.out::println);
    
21
2015-10-20 09: 12: 52Z
  1. La respuesta más relevante y precisa. Encantado para tiene dos traducciones de hecho.
    2017-09-23 11: 57: 39Z

La construcción de bucle "para-cada" de Java permitirá la iteración de dos tipos de objetos:

  •  T[] (matrices de cualquier tipo)
  • java.lang.Iterable<T>

La interfaz Iterable<T> tiene un solo método: Iterator<T> iterator(). Esto funciona en objetos del tipo Collection<T> porque la interfaz Collection<T> se extiende a Iterable<T>.

    
20
2008-09-17 18: 04: 18Z

El concepto de un bucle foreach como se menciona en Wikipedia se destaca a continuación:

  

Sin embargo, a diferencia de otras construcciones de bucles, los bucles de foreach generalmente   mantienen sin contador explícito : esencialmente dicen "haz esto para   todo en este conjunto ", en lugar de" hacer esto x veces ". Esto evita   posibles errores off-by-one y simplifica la lectura del código

Por lo tanto, el concepto de un bucle foreach describe que el bucle no utiliza ningún contador explícito, lo que significa que no es necesario utilizar índices para atravesar la lista, por lo que evita que el usuario cometa un error. Para describir el concepto general de este error off-by-one, tomemos un ejemplo de un bucle para recorrer en una lista utilizando índices.

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

}

Pero supongamos que si la lista comienza con el índice 1, este bucle generará una excepción, ya que no encontrará ningún elemento en el índice 0 y este error se denomina error de uno en uno. Entonces, para evitar este error off-by-one, se utiliza el concepto de un bucle foreach. También puede haber otras ventajas, pero creo que este es el concepto principal y la ventaja de usar un bucle foreach.

    
15
2018-03-16 13: 14: 37Z
 
for (Iterator<String> itr = someList.iterator(); itr.hasNext(); ) {
   String item = itr.next();
   System.out.println(item);
}
    
11
2011-12-19 09: 58: 20Z

Aquí hay una expresión equivalente.

 
for(Iterator<String> sit = someList.iterator(); sit.hasNext(); ) {
    System.out.println(sit.next());
}
    
9
2008-09-17 16: 48: 10Z

También tenga en cuenta que el uso del método "foreach" en la pregunta original tiene algunas limitaciones, como no poder eliminar elementos de la lista durante la iteración.

El nuevo for-loop es más fácil de leer y elimina la necesidad de un iterador separado, pero solo es realmente utilizable en pases de iteración de solo lectura.

    
9
2008-09-17 16: 53: 52Z
  1. En esos casos, el uso de removeIf podría ser la herramienta adecuada
    2018-04-10 18: 57: 54Z

Al usar versiones anteriores de Java, incluyendo Java 7, puede usar el bucle foreach de la siguiente manera.

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

La siguiente es la forma más reciente de usar el bucle foreach en Java 8

(haga un bucle con una lista con forEach + expresión lambda o referencia de método)

 
//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 obtener más información, consulte este enlace.

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

    
9
2018-06-21 11: 05: 15Z

Una alternativa a forEach para evitar "para cada uno":

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

Variante 1 (normal):

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

Variante 2 (ejecución paralela (más rápida)):

 
someList.parallelStream().forEach(listItem -> {
    System.out.println(listItem);
});
    
8
2018-03-16 13: 38: 25Z
  1. Debería haber mencionado que se agregó en Java 1.8
    2017-07-27 14: 42: 57Z
  2. No podemos estar 100% seguros de que se use el mismo hilo. Me gusta usar el formulario for( si quiero asegurarme de que se use el mismo hilo. Me gusta usar la forma de flujo si me gusta permitir la ejecución de multiproceso.
    2019-02-18 12: 27: 40Z

Añade belleza a tu código al eliminar todo el desorden de bucle básico. Da un aspecto limpio a su código, justificado a continuación.

Bucle for normal:

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

Usando para cada:

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

for-each es una construcción sobre una colección que implementa Iterator . Recuerda que tu colección debe implementar Iterator ; de lo contrario no puedes usarlo con for-each.

La siguiente línea se lee como " para cada TimerTask t en la lista. "

 
for (TimerTask t : list)

Hay menos posibilidades de errores en el caso de para cada uno. No tiene que preocuparse por inicializar el iterador o inicializar el contador de bucles y terminarlo (donde haya margen para errores).

    
7
2017-03-31 20: 02: 43Z

En Java 8, introdujeron forEach. Usándolo en la lista, los mapas se pueden enlazar.

Repetir una lista usando cada uno

 
List<String> someList = new ArrayList<String>();
someList.add("A");
someList.add("B");
someList.add("C");

someList.forEach(listItem -> System.out.println(listItem))

o

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

Recorrer un mapa usando cada uno

 
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));

o

 
mapList.forEach((key,value)->{
    System.out.println("Key : " + key + " Value : " + value);
});
    
7
2018-08-30 13: 23: 15Z

Se vería algo así. Muy crufty

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

Hay una buena reseña en para cada en documentación de Sun .

    
6
2018-03-16 13: 05: 04Z

Antes de Java 8, debes usar lo siguiente:

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

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

Sin embargo, con la introducción de Streams en Java 8, puedes hacer lo mismo con mucha menos sintaxis. Por ejemplo, para su someList puede hacer:

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

Puede encontrar más información sobre las transmisiones aquí .

    
6
2018-03-16 13: 40: 15Z

Como han dicho tantas buenas respuestas, un objeto debe implementar el Iterable interface si quiere usar un bucle for-each.

Publicaré un ejemplo sencillo e intentaré explicar de una manera diferente cómo funciona un bucle for-each.

El ejemplo del bucle 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);
        }
    }
}

Luego, si usamos javap para descompilar esta clase, obtendremos este ejemplo de código de bytes:

 
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 en la última línea de la muestra, el compilador convertirá automáticamente el uso de la palabra clave for-each al uso de un Iterator en el momento de la compilación. Eso puede explicar por qué el objeto, que no implementa el Iterable interface, lanzará un Exception cuando intente usar el bucle for-each.

    
5
2017-03-31 20: 05: 03Z
 
public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
            for(int k=0;k<totalsize;k++)
            {
              fullst.addAll();
            }
}
    
3
2016-10-27 11: 55: 00Z

El Java para cada bucle (también conocido como mejorado para bucle) es simplificado versión de un bucle for. La ventaja es que hay menos código para escribir y menos variables para administrar. El inconveniente es que no tiene control sobre el valor del paso ni acceso al índice de bucle dentro del cuerpo del bucle.

Se utilizan mejor cuando el valor del paso es un incremento simple de 1 y cuando solo necesita acceder al elemento de bucle actual. Por ejemplo, si necesita recorrer cada elemento de una matriz o colección sin mirar hacia delante o detrás del elemento actual.

No hay inicialización de bucle, ninguna condición booleana y el valor del paso es implícito y es un incremento simple. Es por eso que se consideran mucho más simples que los regulares para los bucles.

Los bucles mejorados siguen este orden de ejecución:

1) cuerpo del bucle

2) repita desde el paso 1 hasta que se haya recorrido toda la matriz o colección

Ejemplo - Matriz de enteros

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

La variable currentValue contiene el valor actual que se está repartiendo en la matriz intArray. Tenga en cuenta que no hay un valor de paso explícito, siempre es un incremento de 1

Se puede pensar que los dos puntos significan "en". Por lo tanto, los estados de declaración de bucle mejorados: bucle sobre intArray y almacenan el valor int del array actual en la variable currentValue.

Salida:

 
1
3
5
7
9

Ejemplo - Cadena de cadenas

Podemos usar el bucle for-each para iterar sobre una serie de cadenas. Los estados de declaración de bucle: bucle sobre myStrings String array y almacenan el valor de String actual en la variable currentString.

 
String [] myStrings  = {
  "alpha",
  "beta",
  "gamma",
  "delta"
};

for(String currentString : myStrings) {
  System.out.println(currentString);
}

Salida:

 
alpha
beta
gamma
delta

Ejemplo - Lista

El bucle for mejorado también se puede usar para iterar sobre un archivo java.util.List de la siguiente manera:

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

Los estados de declaración de bucle: bucle sobre myList Lista de cadenas y almacenan el valor actual de la lista en la variable currentItem.

Salida:

 
alpha
beta
gamma
delta

Ejemplo: conjunto

El bucle for mejorado también se puede usar para iterar sobre un java.util.Set de la siguiente manera:

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

Los estados de declaración de bucle: bucle sobre mySet Set of Strings y almacenan el valor actual establecido en la variable currentItem. Tenga en cuenta que, dado que se trata de un conjunto, los valores de cadena duplicados no se almacenan.

Salida:

 
alpha
delta
beta
gamma

Fuente: Loops in Java - Ultimate Guide

    
3
2018-05-02 13: 11: 27Z

El lenguaje Java para cada idioma solo se puede aplicar a matrices u objetos de tipo * Iterable . Este idioma está implicit ya que está realmente respaldado por un iterador. El iterador está programado por el programador y, a menudo, utiliza un índice entero o un nodo (según la cadena de datos).Estructura) para realizar un seguimiento de su posición. En el papel es más lento que un bucle for regular, al menos para estructuras "lineales" como matrices y listas, pero proporciona una mayor abstracción.

    
2
2016-03-18 17: 43: 28Z
  1. - 1: esto es mucho menos legible (generalmente): incluso su propio ejemplo (el primero) es incorrecto, ya que deja de lado el primer elemento de la matriz.
    2016-03-18 17: 11: 50Z

Esto parece una locura, pero bueno, funciona

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

Esto funciona. Magic

    
1
2018-01-29 08: 38: 51Z
  1. Esto requiere Java 1.8 +
    2018-02-15 07: 31: 06Z
  2. ni siquiera responde la pregunta de forma remota
    2018-02-16 14: 57: 20Z
 
List<Item> Items = obj.getItems();
for(Item item:Items)
             {
                System.out.println(item); 
             }

Iteriza sobre todos los objetos en la tabla de elementos.

    
- 1
2018-03-27 08: 15: 43Z
  1. El usuario no ha solicitado la sintaxis
    2018-07-06 04: 54: 23Z
fuente colocada aquí