Come funziona il ciclo Java per ogni ciclo?

Il costrutto per ogni è valido anche per gli array. per esempio.

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

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

che è essenzialmente equivalente a

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

Quindi, riassunto generale:
[nsayer] Quanto segue è la forma più lunga di ciò che sta accadendo:

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

Si noti che se è necessario utilizzare i.remove (); nel tuo ciclo, o accedere in qualche modo all'iteratore attuale, non puoi usare l'espressione for (:), poiché l'Iterator effettivo viene semplicemente dedotto.

[Denis Bueno]

È implicito dalla risposta di nsayer, ma vale la pena notare che la sintassi dell'OP per (..) funzionerà quando "someList" è qualcosa che implementa Java.lang.Iterable - non deve essere una lista o una raccolta da java.util. Anche i tuoi stessi tipi, quindi, possono essere usati con questa sintassi.

Il foreachloop , aggiunto in Java 5 (chiamato anche "enhanced for loop"), equivale a usare un Java.util.Iterator - è lo zucchero sintattico per la stessa cosa. Pertanto, quando si legge ciascun elemento, uno per uno e in ordine, un foreachdeve sempre essere scelto su un iteratore, in quanto è più conveniente e conciso.

per ciascuno

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

Iterator

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

Ci sono situazioni in cui devi usare direttamente Iteratorname__. Ad esempio, se si tenta di eliminare un elemento mentre si utilizza foreachcan (will?) Risulta un ConcurrentModificationExceptionname__.

foreachvs. forname__: differenze di base

L'unica differenza pratica tra fore foreachè che, nel caso degli oggetti indicizzabili, non si ha accesso all'indice. Un esempio in cui è richiesto il ciclo fordi base:

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

Sebbene sia possibile creare manualmente una variabile int index separata con foreachname__,

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

non è raccomandato, dal momento che variable-scope non è l'ideale, e il ciclo fordi base è semplicemente il formato standard e previsto per questo caso d'uso.

foreachvs. forname__: prestazioni

Quando si accede alle raccolte, un foreachè significativamente più veloce rispetto all'accesso di base del ciclo forname__. Quando si accede agli array, tuttavia, almeno con gli array primitivi e wrapper, l'accesso tramite gli indici è notevolmente più rapido.

Cronometrare la differenza tra iteratore e accesso all'indice per i primitivi int-array

Gli indici sono 23 - 40 percento più veloce degli iteratori quando si accede agli array into Integername__. Ecco l'output della classe testing in fondo a questo post, che somma i numeri in un array primitive-int di 100 elementi (A è iteratore, B è index):

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

Ho anche eseguito questo per un array Integername__, e gli indici sono ancora il chiaro vincitore, ma solo tra il 18 e il 25 percento più veloce.

Per le raccolte, gli iteratori sono più veloci degli indici

Per un Listdi Integersname__, tuttavia, gli iteratori sono il chiaro vincitore. Basta cambiare l'int-array nella classe di test per:

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

E apporta le modifiche necessarie alla funzione di test (int[] a List<Integer>, lengtha size(), ecc.):

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

In un test sono quasi equivalenti, ma con le raccolte vince l'iteratore.

* Questo post è basato su due risposte che ho scritto su Stack Overflow:

• Usi e sintassi per ogni ciclo in Java

• Devo usare un Iterator o un forloop per iterare?

Altre informazioni:Qual è più efficiente, un ciclo for-each o un iteratore?

La classe di test completa

Ho creato questa classe comparativa del tempo necessario per fare due cose dopo aver letto questa domanda su Stack Overflow:

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

}

Ecco una risposta che non presuppone la conoscenza di Java Iterators. È meno preciso, ma è utile per l'educazione.

Durante la programmazione spesso scriviamo un codice simile al seguente:

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 sintassi foreach consente a questo modello comune di essere scritto in modo più naturale e meno sintatticamente rumoroso.

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

Inoltre questa sintassi è valida per oggetti come elenchi o insiemi che non supportano l'indicizzazione di array, ma che implementano l'interfaccia Java Iterable.

Il ciclo for-each in Java utilizza il meccanismo iteratore sottostante. Quindi è identico al seguente:

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

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

Nelle funzionalità di Java 8 puoi utilizzare questo:

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

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

Produzione

First
Second
Third

È implicito dalla risposta di nsayer, ma vale la pena notare che la sintassi dell'OP per (..) funzionerà quando "someList" è qualsiasi cosa che implementa Java.lang.Iterable - non deve essere una lista, o qualche raccolta da Java.util. Anche i tuoi stessi tipi, quindi, possono essere usati con questa sintassi.

Una sintassi del ciclo foreach è:

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

Esempio:

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

Produzione:

Java
Coffe
Is
Cool

ATTENZIONE: è possibile accedere agli elementi dell'array con il ciclo foreach, ma NON è possibile inizializzarli. Utilizza il ciclo for originale per quello.

ATTENZIONE: devi abbinare il tipo dell'array con l'altro oggetto.

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

Se vuoi modificare elementi, usa il ciclo for originale in questo modo:

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

Ora se scarichiamo s alla console, otteniamo:

hello
2 is cool
hello
hello

Il costrutto del ciclo "for-each" di Java consentirà l'iterazione su due tipi di oggetti:

• T[] (matrici di qualsiasi tipo)
• Java.lang.Iterable<T>

L'interfaccia Iterable<T> ha solo un metodo: Iterator<T> iterator(). Funziona su oggetti di tipo Collection<T> perché l'interfaccia Collection<T> estende Iterable<T>.

Come definito in JLS per-ogni ciclo può avere due forme:

1. Se il tipo di espressione è un sottotipo di Iterable, la traduzione è come:

   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. Se l'espressione ha necessariamente un tipo di matrice T[], allora:

   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 introdotto stream che offrono prestazioni generalmente migliori. Possiamo usarli come:

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

Il concetto di un ciclo di foreach come menzionato in Wikipedia è evidenziato di seguito:

A differenza di altri costrutti loop, tuttavia, i cicli foreach di solito mantengono nessun contatore esplicito : in pratica dicono "fai questo a tutto in questo set", piuttosto che "fai questo x volte". Questo evita potenziali errori off-by-one e semplifica la lettura del codice.

Quindi il concetto di un ciclo foreach descrive che il ciclo non usa alcun contatore esplicito, il che significa che non c'è bisogno di usare gli indici per attraversare l'elenco in modo da salvare l'utente da un errore off-by-one. Per descrivere il concetto generale di questo errore off-by-one, prendiamo un esempio di un ciclo da attraversare in un elenco usando gli indici.

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

}

Ma supponiamo che se la lista inizia con l'indice 1, allora questo ciclo genererà un'eccezione in quanto non troverà alcun elemento nell'indice 0 e questo errore viene chiamato errore off-by-one. Pertanto, per evitare questo errore "fuori-per-uno" viene utilizzato il concetto di un ciclo foreach. Potrebbero esserci anche altri vantaggi, ma questo è quello che penso sia il concetto principale e il vantaggio dell'uso di un ciclo foreach.

Si noti inoltre che l'uso del metodo "foreach" nella domanda originale presenta alcune limitazioni, come il non poter rimuovere elementi dall'elenco durante l'iterazione.

Il nuovo ciclo for è più facile da leggere e rimuove la necessità di un iteratore separato, ma è realmente utilizzabile solo in passaggi di iterazione di sola lettura.

Usando versioni precedenti di Java incluso Java 7 puoi usare il ciclo foreach come segue.

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

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

Di seguito è riportato il modo più recente di utilizzare foreach loop in Java 8

(loop una lista con forEach + espressione lambda o riferimento al metodo)

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

Per maggiori informazioni riferisciti a questo link.

https://www.mkyong.com/Java8/Java-8-foreach-examples/

Ecco un'espressione equivalente.

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

Un'alternativa a forEach per evitare il "per ciascuno":

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

Variante 1 (normale):

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

Variante 2 (esecuzione parallela (più veloce)):

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

Aggiunge bellezza al tuo codice rimuovendo tutto il disordine di loop di base. Dà un aspetto pulito al tuo codice, giustificato di seguito.

Normal for loop:

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

Usando per-ciascuno:

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

for-each è un costrutto su una collezione che implementa Iterator . Ricorda che la tua collezione dovrebbe implementare Iterator ; altrimenti non puoi usarlo con for-each.

La seguente riga è letta come " per ogni elenco di Tim in t. "

for (TimerTask t : list)

Ci sono meno possibilità di errori in caso di for-each. Non devi preoccuparti di inizializzare l'iteratore o inizializzare il contatore del ciclo e terminarlo (dove c'è spazio per errori).

Assomiglierebbe a questo. Molto croccante.

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

C'è una buona annotazione su per ogni nella documentazione di Sun .

Prima di Java 8, è necessario utilizzare quanto segue:

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

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

Tuttavia, con l'introduzione di Streams in Java 8 è possibile fare la stessa cosa con molta meno sintassi. Ad esempio, per il tuo someList puoi fare:

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

Puoi trovare ulteriori informazioni sugli stream qui .

Come hanno risposto tante risposte positive, un oggetto deve implementare Iterable interface se vuole usare un ciclo for-each.

Pubblicherò un semplice esempio e cercherò di spiegare in modo diverso come funziona un ciclo for-each.

L'esempio del ciclo for-each:

public class ForEachTest {

    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();
        list.add("111");
        list.add("222");

        for (String str : list) {
            System.out.println(str);
        }
    }
}

Quindi, se usiamo javapper decompilare questa classe, otterremo questo esempio bytecode:

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

Come possiamo vedere dall'ultima riga del campione, il compilatore convertirà automaticamente l'uso della parola chiave for-each nell'uso di un Iteratorin fase di compilazione. Questo potrebbe spiegare perché l'oggetto, che non implementa il Iterable interface, getterà un Exceptionquando tenta di utilizzare il ciclo for-each.

In Java 8, hanno introdotto per Each. Usando Elenco, le mappe possono essere ripetute.

Effettua il ciclo di una lista usando per ogni

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

Effettua il loop di una mappa utilizzando per ciascuna

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

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

Il Java per ogni ciclo (noto anche come enhanced for loop) è una versione semplificata di un ciclo for. Il vantaggio è che c'è meno codice da scrivere e meno variabili da gestire. Lo svantaggio è che non si ha alcun controllo sul valore del passo e nessun accesso all'indice del loop all'interno del corpo del loop.

Vengono utilizzati al meglio quando il valore del passo è un semplice incremento di 1 e quando è necessario solo accedere all'elemento del loop corrente. Ad esempio, se è necessario eseguire il loop su ogni elemento di una matrice o di una raccolta senza dare una occhiata in anticipo o dietro l'elemento corrente.

Non c'è inizializzazione del ciclo, nessuna condizione booleana e il valore del passo è implicito ed è un semplice incremento. Questo è il motivo per cui sono considerati molto più semplici di quelli normali per loops.

I cicli migliorati seguono questo ordine di esecuzione:

1) corpo del ciclo

2) ripetere dal punto 1 fino a quando l'intero array o raccolta è stata attraversata

Esempio - Array intero

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

La variabile currentValue mantiene il valore corrente in loop sopra nell'array intArray. Nota che non esiste un valore di passo esplicito, è sempre un incremento di 1.

Si può pensare che il colon significhi "in". Pertanto, gli stati della dichiarazione del ciclo avanzato per: loop su intArray e memorizzano il valore corrente dell'array corrente in la variabile currentValue.

Produzione:

1
3
5
7
9

Esempio - Array di stringhe

Possiamo usare il ciclo for-each per scorrere su una serie di stringhe. La dichiarazione del ciclo indica: loop su myStrings Array di stringhe e memorizza il valore di stringa corrente in la variabile currentString.

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

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

Produzione:

alpha
beta
gamma
delta

Esempio - Elenco

Il ciclo for enhanced può anche essere usato per iterare su un Java.util.List come segue:

List<String> myList = new ArrayList<String>();
myList.add("alpha");
myList.add("beta");
myList.add("gamma");
myList.add("delta");

for(String currentItem : myList) {
  System.out.println(currentItem);
}

La dichiarazione del ciclo indica: loop over myList Elenco di stringhe e memorizza il valore List corrente in la variabile currentItem.

Produzione:

alpha
beta
gamma
delta

Esempio - Set

Il ciclo for enhanced può anche essere utilizzato per iterare su un Java.util.Set come segue:

Set<String> mySet = new HashSet<String>();
mySet.add("alpha");
mySet.add("alpha");
mySet.add("beta");
mySet.add("gamma");
mySet.add("gamma");
mySet.add("delta");

for(String currentItem : mySet) {
  System.out.println(currentItem);
}

La dichiarazione del ciclo indica: loop su mySet Set of Strings e memorizza il valore Set corrente in la variabile currentItem. Si noti che poiché questo è un Set, i valori di stringa duplicati non vengono memorizzati.

Produzione:

alpha
delta
beta
gamma

Fonte: Loops in Java - Guida definitiva

L'idioma Java per ogni idioma può essere applicato solo a matrici o oggetti di tipo * Iterable . Questo idioma è implicit come realmente sostenuto da un Iterator. L'Iterator è programmato dal programmatore e spesso utilizza un indice intero o un nodo (a seconda della struttura dati) per tenere traccia della sua posizione. Sulla carta è più lento di un normale ciclo di loop, almeno per le strutture "lineari" come gli array e gli elenchi, ma fornisce una maggiore astrazione.

Questo sembra pazzo ma hey funziona

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

Questo funziona. Magic