foreach ejemplos while - ¿Cómo funciona el bucle de Java 'para cada'?



13 Answers

El constructo para cada uno 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 de

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

[Denis 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 algo 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.

en netbeans ciclo

Considerar:

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

¿Cómo sería el equivalente for bucle sin usar el para cada sintaxis?




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 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 de foreach permite escribir este patrón común de una manera 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.




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



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. Utilice el original for bucle 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 original for así:

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 , 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 funcionan mejor en general. Podemos usarlos como:

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



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



También tenga en cuenta que el uso del método "foreach" en la pregunta original tiene algunas limitaciones, como el hecho de 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.




Agrega 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.

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

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 para cada uno.

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




Se vería algo como esto. Muy crufty

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

Hay una buena reseña sobre cada uno en la documentación de Sun.




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

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

El ejemplo for-each 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);
        }
    }
}

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 la Iterable interface , lanzará una Exception cuando intente usar el bucle for-each .




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 mejorado para bucle) es una versión simplificada 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.

Mejorado para loops sigue este orden de ejecución:

1) cuerpo de 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 mantiene el valor actual que se está repartiendo en la matriz intArray. Note que no hay un valor de paso explícito, siempre es un incremento de 1.

Se puede pensar que el colon significa "en". Por lo tanto, los estados de declaración de bucle mejorados: bucle sobre intArray y almacenan el valor int de la matriz actual en la variable currentValue.

Salida:

1
3
5
7
9

Ejemplo - String Array

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 actual de String 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 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 - Set

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 Set actual 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




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

Iteriza sobre todos los objetos en la tabla Artículos.




Related