¿Cómo funciona el bucle de Java 'para cada'?

Considerar:

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

¿Cuál sería el equivalente for el bucle parece sin usar el para cada ¿sintaxis?

preguntado el 17 de septiembre de 08 a las 14:09

Según JLS tiene dos formas: stackoverflow.com/a/33232565/1216775 -

Hay diferentes tipos de bucle for de Java como se menciona a continuación. El funcionamiento del bucle for es el mismo para todos los tipos y solo varía en la sintaxis. * Simple para bucle (tutorialcup.com/java/…) * Mejorado para bucle: para cada bucle (tutorialcup.com/java/java-for-loop.htm#Enhanced_Java_For_loop) * Anidado para bucle (tutorialcup.com/java/java-for-loop.htm#Nested_For_Loop) * Etiquetado para bucle (tutorialcup.com/java/java-for-loop.htm#Laoted_For_loop) tutorialcup.com/java/java-for-loop.htm -

Podemos usar el bucle for mejorado para iterar elementos de la siguiente colección: Array ArrayList Map Set LinkedList y así sucesivamente. tutorialcup.com/java/java-for-each-loop.htm -

27 Respuestas

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

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

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

Además, si el lado derecho del for (:) el idioma es un array en lugar de un Iterable objeto, el código interno utiliza un contador de índice int y se comprueba contra array.length en lugar de. Ver el Especificación del lenguaje Java.

respondido 03 mar '18, 16:03

Encontré simplemente llamando a un bucle while como while (someList.hasMoreElements ()) {// hacer algo}} - me acerca a la gracia de codificación que esperaba encontrar cuando busqué esta pregunta. - james t snell

Ver también docs.oracle.com/javase/1.5.0/docs/guide/language/foreach.html que explican el bucle foreach (cuando se introdujo) - TeléfonoixS

para desarrolladores de Android Studio: import java.util.Iterator; y import java.lang.Iterable; - dsdsdsdsd

Frustrantemente, java.util.Iterator no implementa Iterable entonces no puedes for(String s : (Iterator<String>)foo). Entiendo por qué es esto, pero is irritante. - cristobal schultz

@ChristopherSchultz podrías hacerlo con lambdas for(String s : (Iterable<String>)() -> foo) - lino

El constructo para cada también es válido para matrices. p.ej

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 utilizar i.remove (); en su ciclo, o acceder al iterador real de alguna manera, no puede usar el modismo for (:), ya que el iterador real simplemente se infiere.

[Dennis Bueno]

Está implícito en la respuesta de nsayer, pero vale la pena señalar que la sintaxis de OP para (..) funcionará cuando "someList" sea 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.

respondido 16 mar '18, 13:03

Yo no diría que el segundo ejemplo es "esencialmente equivalente al primero", ya que si es una lista de valores primitivos, cualquier modificación que haga a los valores no modificará la lista original en el ejemplo 2, pero modificará la lista original en ejemplo 1. - kosaro

El foreach loops, agregado en Java 5 (también llamado "bucle for mejorado"), es equivalente a usar un java.util.Iterator- es azúcar sintáctico para lo mismo. Por tanto, al leer cada elemento, uno a uno y en orden, una foreach siempre debe elegirse sobre 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 debe utilizar un Iterator directamente. Por ejemplo, intentar eliminar un elemento mientras se usa un foreach puede (¿será?) resultar en 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 el básico for Se requiere bucle:

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

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

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

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

foreach vs for: Actuación

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

Cronometraje de la diferencia entre iterador e índice de acceso para primitivas int-arrays

Los índices son 23-40 por ciento más rápido que los iteradores al acceder int or Integer matrices. Aquí está el resultado de la clase de prueba al final de esta publicación, que suma los números en una matriz primitiva-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 durante un Integer array, 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 establecer una List of IntegersSin embargo, los iteradores son los claros ganadores. Simplemente cambie la matriz int 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 las colecciones, gana el iterador.

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

Más información: ¿Qué es más eficiente, un bucle para cada ciclo o un iterador?

La clase de prueba completa

Creé esta clase de comparar el tiempo que se necesita para hacer dos cosas después de leer esta pregunta en Stack Overflow:

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

}

respondido 16 mar '18, 13:03

Esta respuesta es ahora un blog y fue creado 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). - mente literal

Solo un comentario menor aquí, no debe afirmar categóricamente que la sintaxis for (:) es siempre mejor para acceder a las colecciones; si está usando una lista de arreglos, el ciclo for (:) será aproximadamente 2 veces más lento que usar for (int i = 0, len = arrayList.size (); i <len; i ++). Creo que lo mencionaste en el [enlace] ( stackoverflow.com/questions/2113216/…) enlace de todos modos, pero es importante resaltar que ... - Leo

@Leo Es un buen punto. Una ArrayList es una colección, pero está respaldada por una matriz, por lo que lo normal es mejor para ella. - mente literal

Me imagino el for(int value : int_array) {/* loop content */} es más lento en su 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 su prueba. - daiscog

(por cierto, no estoy diciendo que su prueba no sea válida, pero valdría la pena señalar las razones detrás de la diferencia para que las personas puedan elegir lo que es correcto para su situación particular. Si están haciendo una int value = int_array[i]; al comienzo de su bucle for, entonces también podrían usar foreach. A menos que también necesiten acceder al índice, por alguna razón. En resumen, todo depende del contexto.) - daiscog

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

Mientras programamos, a menudo escribimos código que se parece a lo 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 foreach permite que este patrón común se escriba de una manera más natural y menos ruidosa sintácticamente.

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 Java Iterable.

respondido 16 mar '18, 13:03

El bucle for-each en Java utiliza el mecanismo de iterador subyacente. Entonces es idéntico al siguiente:

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

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

respondido 16 mar '18, 13:03

Como se define en JLS for-each loop puede tener dos formas:

  1. Si el tipo de expresión es un subtipo de Iterable entonces 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 necesariamente tiene 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 transmisiones que, en general, funcionan mejor. Podemos usarlos como:

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

Respondido 20 Oct 15, 10:10

La respuesta más relevante y precisa. Enchansed for tiene dos traducciones. - Zarial

Está implícito en la respuesta de nsayer, pero vale la pena señalar que la sintaxis OP para (..) funcionará cuando "someList" sea cualquier cosa que implementa 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.

respondido 16 mar '18, 13:03

fd es correcto: el código interno cuando el lado derecho del modismo for (:) usa un int y array.length en lugar de buscar un Iterator. foros.sun.com/thread.jspa?messageID=2743233 - nsayer

En las funciones de Java 8, puede utilizar esto:

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

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

Salida

First
Second
Third

Respondido el 25 de Septiembre de 17 a las 16:09

esta información aleatoria ni siquiera responde remotamente a la pregunta: Tim

Una sintaxis de 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. Usa el original for bucle para eso.

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

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

Si desea editar elementos, use el original for bucle 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 en la consola, obtenemos:

hello
2 is cool
hello
hello

respondido 16 mar '18, 13:03

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

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

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

Respondido el 17 de Septiembre de 08 a las 19:09

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

Sin embargo, a diferencia de otras construcciones de bucle for, los bucles foreach suelen mantener sin contador explícito: esencialmente dicen "haz esto con todo en este conjunto", en lugar de "haz esto x veces". Esto evita el potencial errores fuera de uno y simplifica la lectura del código.

Entonces, el concepto de un bucle foreach describe que el bucle no usa ningún contador explícito, lo que significa que no hay necesidad de usar índices para recorrer la lista, por lo que ahorra al usuario un error de uno por uno. Para describir el concepto general de este error de uno por uno, tomemos un ejemplo de un bucle para recorrer una lista usando índices.

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

}

Pero suponga que si la lista comienza con el índice 1, entonces 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 por uno. Entonces, para evitar este error de uno por uno, se usa el concepto de un bucle foreach. También puede haber otras ventajas, pero este es el concepto principal y la ventaja de usar un bucle foreach.

respondido 16 mar '18, 13:03

En Java 8, introdujeron forEach. Utilizándola Lista, los mapas se pueden realizar en bucle.

Bucle una 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))

or

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

Haga un bucle en un mapa usando

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

or

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

Respondido 30 ago 18, 14:08

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

Respondido el 19 de diciembre de 11 a las 09:12

El uso de versiones anteriores de Java, incluidas Java 7 puedes usar foreach bucle 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);
        }

A continuación se muestra la forma más reciente de usar foreach incluyete Java 8

(bucle 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/

Respondido el 21 de junio de 18 a las 12:06

Aquí tienes una expresión equivalente.

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

Respondido el 17 de Septiembre de 08 a las 17:09

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 bucle for es más fácil de leer y elimina la necesidad de un iterador separado, pero solo se puede usar en pasadas de iteración de solo lectura.

Respondido el 17 de Septiembre de 08 a las 17:09

En esos casos, el uso de removeIf podría ser la herramienta adecuada - ncmathsadist

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

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

respondido 16 mar '18, 13:03

Debería haber mencionado que se agregó en Java 1.8 - La bibliotecaria

No podemos estar 100% seguros de que se utilice el mismo hilo. Me gusta usar el for( formulario si quiero asegurarme de que se use el mismo hilo. Me gusta usar la forma de flujo si quiero permitir la ejecución multiproceso. - Siniestro

Agrega belleza a su código al eliminar todo el desorden de bucles básico. Le da un aspecto limpio a su código, justificado a continuación.

Regular for bucle:

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

Usando para cada uno:

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

para cada es una construcción sobre una colección que implementa Iterador. Recuerda que tu colección debe implementar Iterador; de lo contrario, no puede 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 for-each. No tiene que preocuparse por inicializar el iterador o inicializar el contador de bucle y terminarlo (donde hay margen para errores).

respondido 31 mar '17, 21:03

Antes de Java 8, debe utilizar 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, puede hacer lo mismo con mucha menos sintaxis. Por ejemplo, para tu someList tu puedes hacer:

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

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

respondido 16 mar '18, 13:03

The foreach loop, added in Java 5 (also called the "enhanced for loop"), is equivalent to using a java.util.Iterator - Alex78191

Se vería más o menos así. Muy cruda.

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

Hay una buena reseña sobre para cada en la Documentación de Sun.

respondido 16 mar '18, 13:03

Como dicen tantas buenas respuestas, un objeto debe implementar el Iterable interface si quiere usar un for-each lazo.

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

El for-each ejemplo de bucle:

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

Entonces, si usamos javap para descompilar esta clase, obtendremos esta muestra 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 del ejemplo, el compilador convertirá automáticamente el uso de for-each palabra clave para el uso de una Iterator en tiempo de compilación. Eso puede explicar por qué el objeto, que no implementa el Iterable interface, lanzará un Exception cuando intenta usar el for-each lazo.

respondido 31 mar '17, 21:03

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

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

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

Los bucles for mejorados siguen este orden de ejecución:

1) cuerpo de bucle

2) repita desde el paso 1 hasta que se haya atravesado 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 repite 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". Entonces, la declaración de bucle for mejorada establece: bucle sobre intArray y almacene el valor int de la matriz actual in la variable currentValue.

Salida:

1
3
5
7
9

Ejemplo: matriz de cadenas

Podemos usar el ciclo for-each para iterar sobre una matriz de cadenas. Los estados de declaración de bucle: recorrer la matriz de cadenas myStrings y almacenar el valor de cadena actual in 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 utilizar para iterar sobre un 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: recorrer myList List of Strings y almacenar el valor de List actual in la variable currentItem.

Salida:

alpha
beta
gamma
delta

Ejemplo: Establecer

El bucle for mejorado también se puede utilizar 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: recorrer el conjunto de cadenas mySet y almacenar el valor actual in 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: Bucles en Java - Guía definitiva

contestado el 02 de mayo de 18 a las 14:05

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

Respondido 27 Oct 16, 12:10

El lenguaje de Java para cada idioma solo se puede aplicar a matrices u objetos de tipo * Iterable. Este modismo es implícitamente ya que realmente está respaldado por un iterador. El Iterador lo programa el programador y, a menudo, utiliza un índice entero o un nodo (según la estructura de datos) para realizar un seguimiento de su posición. Sobre 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.

respondido 18 mar '16, 17:03

-1: esto es mucho menos legible (generalmente): incluso su propio ejemplo (el primero) es incorrecto, ya que omite el primer elemento de la matriz. - Ondrej Skopek

Como muchas de las otras respuestas afirman correctamente, la for each loop es solo azúcar sintáctico sobre el mismo viejo for loop y el compilador lo traduce al mismo antiguo bucle for.

javac (open jdk) tiene un interruptor -XD-printflat, que genera un archivo java con todo el azúcar sintáctico eliminado. el comando completo se ve así

javac -XD-printflat -d src/ MyFile.java

//-d is used to specify the directory for output java file

Así que eliminemos el azúcar sintáctico

Para responder a esta pregunta, creé un archivo y escribí dos versiones de for eachuno con array y otro con un list. mi java archivo se veía así.

import java.util.*;
public class Temp{

    private static void forEachArray(){
        int[] arr = new int[]{1,2,3,4,5};
        for(int i: arr){
            System.out.print(i);
        }
    }

    private static void forEachList(){
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        for(Integer i: list){
            System.out.print(i);
        }
    }
}

Cuando compiled este archivo con el interruptor anterior, obtuve el siguiente resultado.

import java.util.*;

public class Temp {

    public Temp() {
        super();
    }

    private static void forEachArray() {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        for (/*synthetic*/ int[] arr$ = arr, len$ = arr$.length, i$ = 0; i$ < len$; ++i$) {
            int i = arr$[i$];
            {
                System.out.print(i);
            }
        }
    }

    private static void forEachList() {
        List list = Arrays.asList(new Integer[]{Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3), Integer.valueOf(4), Integer.valueOf(5)});
        for (/*synthetic*/ Iterator i$ = list.iterator(); i$.hasNext(); ) {
            Integer i = (Integer)i$.next();
            {
                System.out.print(i);
            }
        }
    }
}

Puede ver que junto con el otro azúcar sintáctico (Autoboxing) para cada bucle se cambió a bucles simples.

Respondido 17 Abr '20, 17:04

Esto parece loco pero bueno, funciona

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

Esto funciona. Simétrica

Respondido el 29 de enero de 18 a las 08:01

Esto requiere Java 1.8 + - BARNI

ni siquiera responde remotamente a la pregunta - Tim

Creo que esto funcionará:

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

Respondido el 26 de enero de 21 a las 18:01

Explique por qué su código e intente responder la pregunta "¿Cómo funciona el bucle de Java 'para cada'?" - fénixstudio

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.