Comment se fait la Java "pour chaque" boucle de travail?
https://stackoverflow.com/questions/85190
-
01-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Considérer:
List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList
for (String item : someList) {
System.out.println(item);
}
Ce serait l'équivalent for boucle ressembler, sans l'aide de l' pour chaque la syntaxe?
La solution
for (Iterator<String> i = someIterable.iterator(); i.hasNext();) {
String item = i.next();
System.out.println(item);
}
Notez que si vous avez besoin d'utiliser i.remove(); dans votre boucle ou d'accéder à l'itérateur réel d'une manière ou d'une autre, vous ne pouvez pas utiliser l'idiome for ( : ) car cet itérateur est simplement déduit.
Comme Denis Bueno l’a noté, ce code fonctionne pour tout objet implémentant le Iterable interface .
De même, si le membre de droite de l'idiome for (:) est à droite, il s'agit d'un array objet plutôt que d'un array.length objet, le code interne utilise un compteur d'index int et vérifie par rapport à <=>. Voir la Spécification du langage Java .
Autres conseils
La construction pour chaque est également valide 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 équivalent à
for (int i = 0; i < fruits.length; i++) {
String fruit = fruits[i];
// fruit is an element of the `fruits` array.
}
Donc, résumé général:
[nsayer] Ce qui suit est le plus long forme 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 i.remove (); dans votre boucle, ou accédez l'itérateur réel d'une certaine manière, vous ne peut pas utiliser l'idiome for (:), car l'Iterator actuel est simplement inféré.
C'est impliqué par la réponse de nsayer, mais il est à noter que le PO pour (..) la syntaxe fonctionnera quand " someList " est tout ce qui implémente java.lang.Iterable - il n'a pas être une liste, ou une collection de java.util. Même vos propres types, donc, peut être utilisé avec cette syntaxe.
L' foreach boucle, a ajouté Java 5 (aussi appelé le "enhanced pour la boucle"), est équivalent à l'utilisation d'un java.util.Iterator--c'est du sucre syntaxique pour la même chose.Par conséquent, lors de la lecture de chaque élément un par un et dans l'ordre, une foreach doit toujours être choisie sur un itérateur, comme il est plus pratique et concis.
foreach
for(int i : intList) {
System.out.println("An element in the list: " + i);
}
Itérateur
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, tentez de supprimer un élément, tout en utilisant un foreach peut (va?) résultat dans un ConcurrentModificationException.
foreach vs for:Différences fondamentales
La seule différence pratique entre for et foreach c'est que, dans le cas de plaquettes indexables objets, vous n'avez pas accès à l'index.Un exemple lorsque la base for la boucle est nécessaire:
for(int i = 0; i < array.length; i++) {
if(i < 5) {
// Do something special
} else {
// Do other stuff
}
}
Bien que vous pouvez créer manuellement un index séparé int variable avec foreach,
int idx = -1;
for(int i : intArray) {
idx++;
...
}
il n'est pas recommandé, car variable-portée n'est pas l'idéal, et la base de for la boucle est tout simplement le standard et le format attendu pour ce cas d'utilisation.
foreach vs for:Performance
Lors de l'accès aux collections, un foreach est nettement plus rapide que la base for de la boucle d'accès au tableau.Lors de l'accès à des tableaux, cependant, au moins primitif, et l'enveloppe-tableaux--l'accès par index est considérablement plus rapide.
Calendrier de la différence entre itérateur et de l'indice d'accès pour la primitive int-tableaux
Index 23-40 pour cent plus rapide que les itérateurs lors de l'accès à int ou Integer les tableaux de.Voici le résultat de l'essai de la classe au bas de ce post, qui sommes les numéros dans une 100 élément primitif-int array (est Un itérateur, B est l'indice):
[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 aussi couru ce, pour une Integer tableau, et les indices sont encore le gagnant clair, mais uniquement entre 18 et 25 pour cent plus rapide.
Pour les collections, les itérateurs sont plus rapides que les indices
Pour un List de Integers, toutefois, les itérateurs sont le gagnant clair.Il suffit de changer le type int-tableau dans le test-classe de:
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 faire les changements nécessaires pour le test de fonction (int[] pour List<Integer>, length pour 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 équivalent, mais avec des collections, itérateur gagne.
*Ce poste est basé sur deux réponses que j'ai écrit sur un Débordement de Pile:
Quelques informations supplémentaires: Ce qui est plus efficace, pour chaque tour de boucle, ou un itérateur?
Le test complet de la classe
J'ai créé ce compare-le-temps-elle-prend-pour-faire-tout-de deux choses classe après la lecture de cette question sur un Débordement de Pile:
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
}
Voici une réponse qui ne suppose pas une connaissance de Java Iterators. C'est moins précis, mais c'est utile pour l'éducation.
Pendant la programmation, nous écrivons souvent un 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 à ce modèle courant d'être écrit de manière plus naturelle et moins bruyante sur le plan syntaxique.
for(char grade : grades) { // foreach grade in grades
System.out.print(grade); // print that grade
}
De plus, cette syntaxe est valable pour des objets tels que des listes ou des ensembles qui ne prennent pas en charge l'indexation par tableau, mais qui implémentent l'interface Java Iterable.
La boucle for-each en Java utilise le mécanisme d'itérateur sous-jacent. Donc, c'est identique à ce qui suit:
Iterator<String> iterator = someList.iterator();
while (iterator.hasNext()) {
String item = iterator.next();
System.out.println(item);
}
Dans 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
Cela est impliqué dans la réponse de nsayer, mais il convient de noter que la syntaxe de OP pour (..) fonctionnera lorsque " someList " est n'importe quoi qui implémente java.lang.Iterable - il ne doit pas nécessairement s'agir d'une liste ou d'une collection de java.util. Par conséquent, même vos propres types peuvent être utilisés avec cette syntaxe.
La syntaxe d'une boucle foreach est la suivante:
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 à l'aide de la boucle foreach, mais vous ne pouvez PAS les initialiser. Utilisez la for boucle originale pour cela.
AVERTISSEMENT: vous devez faire correspondre le type du tableau avec l'autre objet.
for (double b:s) // Invalid-double is not String
Si vous souhaitez modifier des éléments, utilisez la boucle <=> originale 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 nous jetons s sur la console, nous obtenons:
hello
2 is cool
hello
hello
Comme défini dans JLS pour Chaque boucle peut prendre deux formes:
-
Si le type d'expression est un sous-type de
Iterable, la traduction est la suivante: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 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 pouvons les utiliser comme:
someList.stream().forEach(System.out::println);
Arrays.stream(someArray).forEach(System.out::println);
Le Java " pour chaque " la construction en boucle 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> car l'interface <=> s'étend <=>.
Le concept de boucle foreach mentionné dans Wikipedia est mis en évidence ci-dessous:
Contrairement aux autres constructions de boucles for, toutefois, les boucles foreach généralement maintenir pas de compteur explicite : ils disent essentiellement & "faire ceci pour tout dans cet ensemble & ";" plutôt que & "faire ceci x fois &"; Cela évite erreurs off-by-one potentielles et simplifie la lecture du code.
Ainsi, le concept de boucle foreach décrit le fait que la boucle n’utilise aucun compteur explicite, ce qui signifie qu’il n’est pas nécessaire d’utiliser des index pour parcourir la liste, ce qui évite à l’utilisateur une erreur unique. Pour décrire le concept général de cette erreur unique, prenons un exemple de boucle à parcourir dans une liste à l’aide d’index.
// In this loop it is assumed that the list starts with index 0
for(int i=0; i<list.length; i++){
}
Mais supposons que si la liste commence par l'index 1, cette boucle lève une exception car elle ne trouvera aucun élément à l'index 0 et cette erreur est appelée une erreur off-by-one. Donc, pour éviter cette erreur "one-by-one", le concept de boucle foreach est utilisé. Il peut aussi y avoir d’autres avantages, mais c’est à mon sens le principal concept et le principal 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 " foreach " La méthode de la question initiale présente certaines limitations, telles que l'impossibilité de supprimer des éléments de la liste pendant l'itération.
La nouvelle boucle for est plus facile à lire et supprime le besoin d'un itérateur séparé, mais elle n'est vraiment utilisable que dans les passes d'itération en lecture seule.
En utilisant les anciennes versions de Java, y compris Java 7, vous pouvez utiliser la 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);
}
Voici la toute dernière façon d'utiliser la Java 8 boucle dans forEach
(boucle une liste avec <=> + expression lambda ou référence de méthode)
//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, consultez ce lien.
Une alternative à forEach afin d'éviter votre " pour chaque ":
List<String> someList = new ArrayList<String>();
Variante 1 (en clair):
someList.stream().forEach(listItem -> {
System.out.println(listItem);
});
Variante 2 (exécution parallèle (plus rapide)):
someList.parallelStream().forEach(listItem -> {
System.out.println(listItem);
});
Cela ajoute de la beauté à votre code en supprimant tout le fouillis de boucle en boucle. Cela donne à votre code un aspect épuré, justifié ci-dessous.
Boucle normale for:
void cancelAll(Collection<TimerTask> list) {
for (Iterator<TimerTask> i = list.iterator(); i.hasNext();)
i.next().cancel();
}
Utilisation de-each:
void cancelAll(Collection<TimerTask> list) {
for (TimerTask t : list)
t.cancel();
}
for-each est une construction par rapport à une collection qui implémente Iterator . N'oubliez pas que votre collection doit implémenter Iterator ; sinon, vous ne pouvez pas l'utiliser avec pour chacun.
La ligne suivante est lue comme & "; pour chaque TimerTask t dans la liste. &";
for (TimerTask t : list)
Il y a moins de risque d'erreur en cas de pour-chacun. Vous n'avez pas à vous préoccuper de l'initialisation de l'itérateur ou du compteur de boucle et de sa terminaison (lorsqu'il existe une marge d'erreur).
Dans Java 8, ils introduisaient forEach. En utilisant cette liste, les cartes peuvent être mises en boucle.
Boucler une liste en 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);
});
Boucler une carte en 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);
});
Cela ressemblerait à quelque chose comme ça. Très cruel
for (Iterator<String> i = someList.iterator(); i.hasNext(); )
System.out.println(i.next());
Il existe un bon résumé sur pour chaque dans Documentation de Sun .
Avant Java 8, vous devez utiliser les éléments suivants:
Iterator<String> iterator = someList.iterator();
while (iterator.hasNext()) {
String item = iterator.next();
System.out.println(item);
}
Cependant, avec l'introduction de Streams dans 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);
Pour en savoir plus sur les flux ici .
Comme beaucoup de bonnes réponses l'ont dit, un objet doit implémenter le Iterable interface s'il veut utiliser une boucle for-each.
Je vais poster un exemple simple et essayer d'expliquer différemment le fonctionnement d'une javap boucle.
L'exemple Iterator de la 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 Exception pour décompiler cette classe, nous obtiendrons cet exemple de code intermédiaire:
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 pouvons le voir à la dernière ligne de l'exemple, le compilateur convertira automatiquement l'utilisation du mot clé <=> en l'utilisation d'un <=> lors de la compilation. Cela peut expliquer pourquoi l’objet, qui n’implémente pas le <=>, jette un <=> quand il essaie d’utiliser la boucle <=>.
public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
for(int k=0;k<totalsize;k++)
{
fullst.addAll();
}
}
Le Java pour chaque boucle est simplifié. version d'une boucle for. 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 l'étape et aucun accès à l'index de la boucle à l'intérieur du corps de la boucle.
Elles sont mieux utilisées lorsque la valeur de pas est un simple incrément de 1 et que vous n’avez besoin que d’un accès à l’élément de boucle en cours. Par exemple, si vous avez besoin de parcourir tous les éléments d'un tableau ou d'une collection sans regarder derrière ou derrière l'élément en cours.
Il n'y a pas d'initialisation de boucle, pas de condition booléenne et la valeur de pas est implicite et constitue un simple incrément. C’est pourquoi elles sont considérées beaucoup plus simples que les boucles classiques.
Les boucles for améliorées suivent cet ordre d'exécution:
1) corps de la boucle
2) recommencez à partir de l'étape 1 jusqu'à ce que tout le tableau ou la collection ait été parcouru
Exemple & # 8211; Tableau d'entiers
int [] intArray = {1, 3, 5, 7, 9};
for(int currentValue : intArray) {
System.out.println(currentValue);
}
La variable currentValue conserve la valeur actuelle en boucle dans le tableau intArray. Notez qu'il n'y a pas de valeur de pas explicite & # 8217; & # 8211; & # 8217; toujours une augmentation de 1.
On peut penser que le côlon signifie & # 8220; in & # 8221 ;. Ainsi, les états améliorés de déclaration de boucle: boucle sur intArray et stocke la valeur int actuelle du tableau dans dans la variable currentValue.Sortie:
1
3
5
7
9
Exemple & # 8211; Tableau de chaînes
Nous pouvons utiliser la boucle for-each pour parcourir un tableau de chaînes. La déclaration de boucle indique: boucle sur le tableau myStrings String et stocke la valeur de chaîne actuelle dans dans la variable currentString.
String [] myStrings = {
"alpha",
"beta",
"gamma",
"delta"
};
for(String currentString : myStrings) {
System.out.println(currentString);
}
Sortie:
alpha
beta
gamma
delta
Exemple & # 8211; Liste
La boucle for améliorée peut également être utilisée pour effectuer une itération sur un fichier java.util.List 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 chaînes myList et stocke la valeur de liste actuelle dans la variable currentItem.
Sortie:
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);
}
Exemple & # 8211; Définir
La boucle for améliorée peut également être utilisée pour effectuer une itération sur un fichier java.util.Set comme suit:
alpha
delta
beta
gamma
La déclaration de boucle indique: boucle sur le jeu de chaînes mySet et stocke la valeur de jeu actuelle dans dans la variable currentItem. Notez que, puisqu'il s'agit d'un ensemble, les valeurs de chaîne en double ne sont pas stockées.
Sortie:
<*>Les expressions Java for-idiom ne peuvent être appliquées qu'à des tableaux ou des objets de type * Iterable . Cet idiome est implicite car il est véritablement soutenu par un itérateur. L'Iterator est programmé par le programmeur et utilise souvent un index entier ou un nœud (en fonction de la structure de données) pour garder une trace de sa position. Sur le papier, il est plus lent qu'une boucle for normale, au moins pour & "Linéaire &"; structures comme les tableaux et les listes, mais il fournit une plus grande abstraction.
Cela a l'air fou mais bon ça marche
List<String> someList = new ArrayList<>(); //has content
someList.forEach(System.out::println);
Cela fonctionne. Magie
List<Item> Items = obj.getItems();
for(Item item:Items)
{
System.out.println(item);
}
Itère sur tous les objets de la table Items.
