¿Cómo funciona el bucle Java 'para cada'?
https://stackoverflow.com/questions/85190
-
01-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
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 aspecto del bucle sin usar el para cada ¿sintaxis?
Solución
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 ( : ) modismo, ya que el iterador real simplemente se infiere.
Como señaló Denis Bueno, este código funciona para cualquier objeto que implemente el Iterable interfaz.
Además, si el lado derecho del for (:) modismo es un array en lugar de un Iterable objeto, el código interno utiliza un contador de índice int y lo compara con array.length en cambio.Ver el Especificación del lenguaje Java.
Otros consejos
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:
[ensayo] 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 I.Remove ();En su bucle, o acceder al iterador real de alguna manera, no puede usar el para (:) Idiom, ya que el iterador real simplemente se infiere.
Está implícito en la respuesta de Nsayer, pero vale la pena señalar que la sintaxis de OP para (...) funcionará cuando "somelista" sea algo 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, se pueden usar con esta sintaxis.
El foreach bucle, añadido 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 lo tanto, al leer cada elemento, uno por uno y en orden, aparece un foreach Siempre se debe elegir en lugar de un iterador, ya que es más conveniente y conciso.
para cada
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 utilizar un Iterator directamente.Por ejemplo, intentar eliminar un elemento mientras se utiliza un foreach puede (¿dará?) resultar en una 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 se tiene acceso al índice.Un ejemplo cuando lo 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 podría crear manualmente una variable int de índice separada con foreach,
int idx = -1;
for(int i : intArray) {
idx++;
...
}
no es recomendable, ya que Alcance variable no es ideal, y lo 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, un foreach es significativamente más rápido que el básico for acceso a la matriz del bucle.Sin embargo, al acceder a matrices, al menos con matrices primitivas y envolventes, el acceso a través de índices es dramáticamente más rápido.
Calcular la diferencia entre el acceso al iterador y al índice para matrices internas primitivas
Los índices son 23-40 por ciento más rápido que los iteradores al acceder int o 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 int primitiva 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 por un Integer La matriz y los índices siguen siendo el claro ganador, pero sólo entre un 18 y un 25 por ciento más rápidos.
Para colecciones, los iteradores son más rápidos que los índices.
Para 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 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 uno o un iterador?
La clase de prueba completa
Creé esta clase para comparar el tiempo que lleva hacer dos cosas después de leer esta pregunta en desbordamiento de pila:
import java.text.NumberFormat;
import java.util.Locale;
/**
<P>{@code java TimeIteratorVsIndexIntArray 1000000}</P>
@see <CODE><A HREF="https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java">https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java</A></CODE>
**/
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
}
Aquí hay una respuesta que no supone conocimiento de los iteradores de Java.Es menos preciso, pero es útil para la educación.
Mientras programamos, a menudo escribimos 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 foreach permite escribir este patrón común 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.
El bucle for-each en Java utiliza el mecanismo iterador subyacente.Entonces es idéntico al siguiente:
Iterator<String> iterator = someList.iterator();
while (iterator.hasNext()) {
String item = iterator.next();
System.out.println(item);
}
En las funciones de Java 8 puedes usar esto:
List<String> messages = Arrays.asList("First", "Second", "Third");
void forTest(){
messages.forEach(System.out::println);
}
Producción
First
Second
Third
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 implementa java.lang.Iterable; no tiene que ser una lista o alguna colección de java.util.Por lo tanto, incluso sus propios tipos se pueden utilizar con esta sintaxis.
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);
}
Producción:
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, utilice 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 a la consola, obtenemos:
hello
2 is cool
hello
hello
Como se define en JLS El bucle for-each puede tener dos formas:
Si el tipo de Expresión es un subtipo de
Iterableentonces 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); }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 secuencias que generalmente funcionan mejor.Podemos usarlos como:
someList.stream().forEach(System.out::println);
Arrays.stream(someArray).forEach(System.out::println);
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 solo un método: Iterator<T> iterator().Esto funciona en objetos de tipo Collection<T> porque el Collection<T> la interfaz se extiende Iterable<T>.
El concepto de bucle foreach mencionado en Wikipedia se destaca a continuación:
Sin embargo, a diferencia de otras construcciones de bucle, los bucles foreach generalmente mantienen sin contador explícito:Básicamente dicen "Haz esto a todo en este conjunto", en lugar de "hacer esto x veces".Esto evita el potencial errores uno por uno y hace que el código sea más sencillo de leer.
Entonces, el concepto de bucle foreach describe que el bucle no utiliza ningún contador explícito, lo que significa que no es necesario utilizar índices para recorrer la lista, por lo que evita que el usuario cometa errores uno por uno.Para describir el concepto general de este error de uno en 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 supongamos 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 uno por uno, se utiliza el concepto de bucle foreach.Puede haber otras ventajas también, pero creo que este es el concepto principal y la ventaja de usar un bucle foreach.
for (Iterator<String> itr = someList.iterator(); itr.hasNext(); ) {
String item = itr.next();
System.out.println(item);
}
He aquí una expresión equivalente.
for(Iterator<String> sit = someList.iterator(); sit.hasNext(); ) {
System.out.println(sit.next());
}
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 en realidad solo se puede utilizar en pasadas de iteración de solo lectura.
Utilizar 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 utilizar foreach incluyete Java 8
(recorre 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 más información consulte este enlace.
Una alternativa a forEach para evitar tu "para cada uno":
List<String> someList = new ArrayList<String>();
Variante 1 (liso):
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);
});
Agrega belleza a su código al eliminar todo el desorden de bucles básico.Le da una apariencia limpia a su código, justificado a continuación.
Normal 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 podrás 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 caso de for-each.No tiene que preocuparse por inicializar el iterador o inicializar el contador de bucle y finalizarlo (donde hay posibilidades de errores).
En Java 8, introdujeron forEach.Usando su Lista, los mapas se pueden repetir.
Hacer un bucle en una lista usando para 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);
});
Realizar un bucle en un mapa usando para 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);
});
Se vería algo como esto.Muy crujiente.
for (Iterator<String> i = someList.iterator(); i.hasNext(); )
System.out.println(i.next());
Hay un buen artículo sobre para cada en el Documentación solar.
Antes de Java 8, era necesario 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 puedes hacer lo mismo con mucha menos sintaxis.Por ejemplo, para tu someList tu puedes hacer:
someList.stream().forEach(System.out::println);
Puedes encontrar más sobre transmisiones. aquí.
Como dijeron tantas buenas respuestas, un objeto debe implementar el Iterable interface si quiere usar un for-each bucle.
Publicaré un ejemplo simple y trataré de 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 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 del ejemplo, el compilador convertirá automáticamente el uso de for-each palabra clave para el uso de un Iterator en tiempo de compilación.Eso puede explicar por qué el objeto, que no implementa el Iterable interface, lanzará un Exception cuando intenta utilizar el for-each bucle.
public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
for(int k=0;k<totalsize;k++)
{
fullst.addAll();
}
}
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 ni 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 acceso al elemento del 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, 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 normales.
Los bucles for 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 repite en la matriz intArray.Observe que no hay un valor de paso explícito: siempre es un incremento de 1.
Se puede pensar que los dos puntos significan "dentro".Entonces, la declaración de bucle for mejorada establece:recorra intArray y almacene el valor int de la matriz actual en la variable valor actual.
Producción:
1
3
5
7
9
Ejemplo: matriz de cadenas
Podemos usar el bucle for-each para iterar sobre una matriz de cadenas.La declaración del bucle dice:recorra la matriz de cadenas myStrings y almacene el valor de cadena actual en la variable cadena actual.
String [] myStrings = {
"alpha",
"beta",
"gamma",
"delta"
};
for(String currentString : myStrings) {
System.out.println(currentString);
}
Producción:
alpha
beta
gamma
delta
Ejemplo: lista
El bucle for mejorado también se puede utilizar para iterar sobre 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);
}
La declaración del bucle dice:recorra la lista myList de cadenas y almacene el valor de la lista actual en la variable elemento actual.
Producción:
alpha
beta
gamma
delta
Ejemplo: conjunto
El bucle for mejorado también se puede utilizar para iterar sobre 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);
}
La declaración del bucle dice:recorra el conjunto de cadenas mySet y almacene el valor del conjunto actual en la variable elemento actual.Tenga en cuenta que, dado que se trata de un conjunto, los valores de cadena duplicados no se almacenan.
Producción:
alpha
delta
beta
gamma
Fuente: Bucles en Java – Guía definitiva
El modismo Java para cada uno solo se puede aplicar a matrices u objetos de tipo *Iterable.Este modismo es implícito 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 normal, al menos para estructuras "lineales" como matrices y listas, pero proporciona una mayor abstracción.
Esto parece una locura pero bueno, funciona.
List<String> someList = new ArrayList<>(); //has content
someList.forEach(System.out::println);
Esto funciona. magia
List<Item> Items = obj.getItems();
for(Item item:Items)
{
System.out.println(item);
}
Itera sobre todos los objetos de la tabla Elementos.
