Comment fonctionne la boucle Java 'pour chaque'?

La construction pour chaque est également valable pour les tableaux. par exemple

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

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

, qui est essentiellement l'équivalent de

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

Donc, dans l'ensemble résumé:

[nsayer] La suite est de la forme longue de ce qui se passe:

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

notez que si vous devez utiliser j'.remove(); dans la boucle, ou de l'accès réel itérateur d'une certaine façon, vous ne peut pas utiliser le( : ) l'idiome, depuis L'itérateur réel est simplement déduire.

[Denis Bueno]

c'est implicite dans la réponse de nsayer, mais il est intéressant de noter que l'OP pour(..) la syntaxe fonctionnera quand "someList" est tout ce qui met en œuvre Java.lang.Itérable -- il n'a pas pour être une liste ou un ensemble de Java.util. Même vos propres types, par conséquent, peut être utilisé avec ce syntaxe.

Voici une réponse qui ne suppose pas la connaissance des itérateurs Java. Elle est moins précise, mais utile pour l'éducation.

lors de la programmation, nous écrivons souvent du code qui ressemble à ce qui suit:

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 syntaxe foreach permet d'écrire ce motif commun de manière plus naturelle et moins bruyante.

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

de plus cette syntaxe est valide pour des objets tels que des listes ou des ensembles qui ne prennent pas en charge l'indexation des tableaux, mais qui implémentent l'interface itérable Java.

le foreach boucle , ajouté dans Java 5 (également appelé" enhanced for loop"), est équivalent à l'utilisation d'un java.util.Iterator --c'est du sucre syntaxique pour la même chose. Par conséquent, lorsqu'on lit chaque élément, un par un et dans l'ordre, il faut toujours choisir un foreach plutôt qu'un itérateur, car il est plus pratique et concis.

foreach

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

il y a des situations où vous devez utiliser un Iterator directement. Par exemple, essayer de supprimer un élément en utilisant un foreach peut (will? un ConcurrentModificationException .

foreach vs. for : différences fondamentales

la seule différence pratique entre for et foreach est que, dans le cas d'objets indexables, vous n'avez pas accès à l'index. Un exemple où la boucle de base for est requise:

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

bien que vous puissiez créer manuellement un index int-variable séparé avec foreach ,

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

il n'est pas recommandé, car à portée variable n'est pas idéal, et la boucle de base for est simplement le format standard et attendu pour ce cas d'utilisation.

foreach vs. for : Performance

Lorsqu'on accède à des collections, un foreach est beaucoup plus rapide que le tableau d'accès de base de la boucle for . Lors de l'accès aux tableaux, cependant--au moins avec les tableaux primitifs et les tableaux d'enrubannage--l'accès via les index est dramatiquement plus rapide.

le moment la différence entre itérateur et de l'indice d'accès pour la primitive int-tableaux

indices sont 23- 40 pourcentage plus rapide que les itérateurs lors de l'accès aux tableaux int ou Integer . Voici la sortie de la classe testing au bas de ce post, qui résume les nombres dans un tableau primitif-int de 100 éléments (A est iterator, B est 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)

j'ai également couru cela pour un Integer tableau, et les index sont toujours le gagnant clair, mais seulement entre 18 et 25 pour cent plus rapide.

pour les collections, les itérateurs sont plus rapides que les index

Pour un List de Integers , cependant, les itérateurs sont le gagnant clair. Il suffit de changer l'int-array dans la classe test en:

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

et apporter les modifications nécessaires à la fonction d'essai ( int[] en List<Integer> , length en 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)

dans un test ils sont presque équivalents, mais avec les collections, iterator gagne.

*Ce poste est basé sur deux réponses que j'ai écrit sur Débordement De La Pile:

• Utilisations et syntaxe pour chaque boucle en Java

• dois-je utiliser un itérateur ou un forloop pour itérer?

plus d'informations: Quel est le plus efficace, une boucle pour chaque boucle, ou un itérateur?

L'ensemble des essais de la classe

j'ai créé cette classe de comparaison-le-temps-qu'il-faut-faire-deux-choses après avoir lu cette question on Stack Overflow:

import  java.text.NumberFormat;
import  java.util.Locale;

/**
   <P>{@code java TimeIteratorVsIndexIntArray 1000000}</P>

   @see  <CODE><A HREF="/q/how-do-i-time-a-method-s-execution-in-java-17185/"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

}

la boucle pour chaque boucle en Java utilise le mécanisme itérateur sous-jacent. Il est donc identique à ce qui suit:

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

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

dans les fonctionnalités de Java 8 Vous pouvez utiliser ceci:

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

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

sortie

First
Second
Third

c'est implicite dans la réponse de nsayer, mais il est intéressant de noter que L'OP est pour(..) la syntaxe fonctionnera lorsque "someList" est anything qui implémente java.lang.Itérable -- il n'a pas à être une liste ou un ensemble de java.util. Même vos propres types, par conséquent, peuvent être utilisés avec cette syntaxe.

une syntaxe de boucle foreach est:

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

exemple:

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

sortie:

Java
Coffe
Is
Cool

AVERTISSEMENT: Vous pouvez accéder aux éléments d'un tableau avec la boucle foreach, mais vous ne pouvez PAS initialiser. Utilisez la boucle originale for pour cela.

AVERTISSEMENT: Vous devez faire correspondre le type de la matrice avec l'autre objet.

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

si vous voulez modifier des éléments, utilisez l'original for boucle comme ceci:

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

maintenant si on décharge s sur la console, on obtient:

hello
2 is cool
hello
hello

la construction de boucle Java "pour-chaque" permettra l'itération sur deux types d'objets:

• T[] (tableaux de tout type)
• java.lang.Iterable<T>

l'interface Iterable<T> n'a qu'une méthode: Iterator<T> iterator() . Cela fonctionne sur les objets de type Collection<T> parce que l'interface Collection<T> s'étend Iterable<T> .

comme défini dans JLS pour - chaque boucle peut avoir deux formes:

1. si le type d'Expression est un sous-type de Iterable alors la traduction est comme:

   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 L'Expression a nécessairement un type de tableau T[] alors:

   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 a introduit des flux qui fonctionnent généralement mieux. Nous peut les utiliser comme:

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

le concept d'une boucle foreach comme mentionné dans Wikipedia est mis en évidence ci-dessous:

à la différence d'autres pour les constructions de boucle, cependant, foreach boucles habituellement maintenir pas de compteur explicite : ils disent en substance "le faire pour tout dans ce jeu", plutôt que "faire x fois". Cela évite erreurs potentielles off-by-one et rend le code plus simple à lire.

ainsi le concept d'une boucle foreach explique que la boucle n'utilise pas de compteur explicite ce qui signifie qu'il n'est pas nécessaire d'utiliser les index pour parcourir la liste ainsi il sauve l'utilisateur de tout-en-un message d'erreur. Pour décrire le concept général de ce tout-en-un erreur, prenons un exemple d'une boucle à parcourir dans une liste à l'aide des indices.

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

}

mais supposons que la liste commence par l'index 1 alors cette boucle va lancer une exception car elle ne trouvera aucun élément à l'index 0 et cette erreur est appelée une-par-une erreur. Pour éviter cette erreur, on utilise le concept d'une boucle foreach. Il peut y avoir d'autres avantages, mais c'est ce que je pense est le concept principal et l'avantage de l'utilisation d'une boucle foreach.

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

voici une expression équivalente.

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

notez également que l'utilisation de la méthode" foreach " dans la question originale comporte certaines limites, comme le fait de ne pas pouvoir supprimer des éléments de la liste au cours de l'itération.

La nouvelle boucle for est plus facile à lire et supprime la nécessité d'itérateur, mais n'est réellement utilisable en lecture seule itération passe.

il ajoute de la beauté à votre code en enlevant tous les clutter de boucle de base. Il donne un look propre à votre code, justifié ci-dessous.

normal for boucle:

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

utilisant pour chacun:

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

for-each est une construction sur une collection qui met en œuvre les Itérateur . Rappelez-vous que, votre collection devrait mettre en œuvre Iterator ; sinon, vous ne pouvez pas l'utiliser avec pour-chacun.

la ligne suivante se lit comme suit: pour chaque masque de temps dans la liste. "

for (TimerTask t : list)

il y a moins de risque d'erreurs dans le cas de pour chacun. Vous n'avez pas à vous soucier d'initialiser l'itérateur ou d'initialiser le compteur de boucle et de le terminer (lorsqu'il y a possibilité d'erreurs).

une alternative à forEach afin d'éviter Votre "pour chacun":

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

variante 1 (simple):

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

variante 2 (exécution parallèle (plus rapide)):

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

ça ressemblerait à ça. Très crufty.

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

il y a une bonne écriture sur pour chaque dans la Sun documentation .

avant Java 8, vous devez utiliser ce qui suit:

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

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

cependant, avec L'introduction de Streams en Java 8, Vous pouvez faire la même chose avec beaucoup moins de syntaxe. Par exemple, pour votre someList vous pouvez faire:

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

vous pouvez en savoir plus sur les cours d'eau ici .

en utilisant des versions anciennes de Java, y compris Java 7 vous pouvez utiliser foreach boucle comme suit.

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

ci-dessous est la toute dernière façon d'utiliser foreach boucle dans Java 8

(en boucle une Liste avec forEach + lambda expression ou d'une méthode de référence)

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

pour plus d'informations, référez-vous à ce lien.

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

comme tant de bonnes réponses l'ont dit, un objet doit implémenter la boucle Iterable interface s'il veut utiliser une boucle for-each .

je vais poster un exemple simple et essayer d'expliquer d'une manière différente comment fonctionne une boucle for-each .

le for-each exemple de boucle:

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

ensuite, si nous utilisons javap pour décomposer cette classe, nous obtiendrons cet échantillon de 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;

comme nous peut voir de la dernière ligne de l'échantillon, le compilateur convertira automatiquement l'utilisation du mot-clé for-each à l'utilisation d'un Iterator au moment de compiler. Cela explique peut-être pourquoi object, qui n'implémente pas la boucle Iterable interface , lancera une boucle Exception lorsqu'il tentera d'utiliser la boucle for-each .

en Java 8, ils ont introduit forEach. En utilisant la liste it, les cartes peuvent être en boucle.

Boucle une liste utilisant pour chaque

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

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

ou

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

Boucle Une Carte utilisant pour chaque

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

ou

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

le langage Java pour-chaque idiome ne peut être appliqué qu'aux tableaux ou objets de type *itérable . Cet idiome est implicite comme il est vraiment appuyé par un itérateur. L'itérateur est programmé par le programmeur et utilise souvent un indice entier ou un noeud (selon la structure des données) pour garder la trace de sa position. Sur le papier, il est plus lent qu'une boucle régulière pour, un moins pour les structures" linéaires " comme les tableaux et les listes, mais il fournit une plus grande abstraction.

le Java pour chaque boucle (aka enhanced for loop) est une version simplifiée de A pour boucle. L'avantage est qu'il y a moins de code à écrire et moins de variables à gérer. L'inconvénient est que vous n'avez aucun contrôle sur la valeur de pas et aucun accès à l'index de boucle à l'intérieur du corps de boucle.

ils sont mieux utilisés quand la valeur de pas est un simple incrément de 1 et quand vous avez besoin seulement d'accéder à l'élément de boucle courante. Par exemple, si vous besoin de boucler chaque élément d'un tableau ou D'une Collection sans regarder en avant ou en arrière de l'élément courant.

il n'y a pas d'initialisation de boucle, pas de condition booléenne et la valeur de pas est implicite et est un simple incrément. C'est pourquoi ils sont considérés comme beaucoup plus simples que réguliers pour les boucles.

Renforcée pour boucles de suivre cet ordre d'exécution:

1) corps de boucle

2) répéter à partir de l'étape 1 jusqu'à tout le réseau ou la collection a été traversé

Exemple De Tableau Entier

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

la variable currentValue contient la valeur courante en boucle dans le tableau intArray. Notez qu'il n'y a pas de valeur de pas explicite – c'est toujours un incrément de 1.

on peut penser que le colon signifie"dans". Ainsi la déclaration enhanced for loop stipule: loop over intArray et stocker le tableau courant int valeur dans la variable currentValue.

sortie:

1
3
5
7
9

Exemple De Tableau De Chaîne De

nous pouvons utiliser la boucle pour-chaque pour itérer sur un tableau de chaînes. La déclaration loop stipule: loop over myStrings String array et stocke la valeur de la chaîne de caractères actuelle dans la variable currentString.

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

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

sortie:

alpha
beta
gamma
delta

Exemple-Liste

la boucle améliorée pour peut aussi être utilisée pour itérer sur un java.util.Énumérer comme suit:

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 déclaration de boucle indique: boucle sur la liste de mylist de chaînes et de stocker la valeur de liste actuelle dans la variable currentItem.

sortie:

alpha
beta
gamma
delta

exemple – Jeu

la boucle améliorée pour peut aussi être utilisée pour itérer sur un java.util.Défini comme suit:

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 déclaration de boucle stipule: boucle sur mySet ensemble de chaînes et stocker la valeur D'ensemble actuelle dans la variable currentItem. Notez que puisqu'il s'agit d'un ensemble, les valeurs des chaînes dupliquées ne sont pas stockées.

sortie:

alpha
delta
beta
gamma

Source: Loops in Java-Guide Ultime

ça a l'air fou mais ça marche

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

ça marche. Magie

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

Itère sur tous les objets dans la table des Articles.