Come funziona il ciclo Java "for each"?
https://stackoverflow.com/questions/85190
-
01-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Prendere in considerazione:
List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList
for (String item : someList) {
System.out.println(item);
}
Quale sarebbe l'equivalente? for aspetto del loop senza utilizzare il file per ciascuno sintassi?
Soluzione
for (Iterator<String> i = someIterable.iterator(); i.hasNext();) {
String item = i.next();
System.out.println(item);
}
Tieni presente che se è necessario utilizzare i.remove(); nel tuo ciclo o accedi all'iteratore effettivo in qualche modo, non puoi utilizzare il file for ( : ) idioma, poiché l'iteratore effettivo è semplicemente dedotto.
Come notato da Denis Bueno, questo codice funziona per qualsiasi oggetto che implementa il file Iterable interfaccia.
Inoltre, se il lato destro del for (:) l'idioma è un array piuttosto che un Iterable oggetto, il codice interno utilizza un contatore di indice int e controlla array.length Invece.Vedi il Specifica del linguaggio Java.
Altri suggerimenti
Il costrutto per ciascuno è 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 è sostanzialmente equivalente a
for (int i = 0; i < fruits.length; i++) {
String fruit = fruits[i];
// fruit is an element of the `fruits` array.
}
Quindi, riepilogo generale:
[nsayer] Quella che 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 all'iteratore effettivo in qualche modo, non puoi usare il For (:) idioma, poiché l'iteratore effettivo è semplicemente dedotto.
È implicito dalla risposta di Nsayer, ma vale la pena notare che la sintassi di (..) funzionerà quando "somelista" è tutto ciò che implementa java.lang.iterable - non deve essere un elenco o una raccolta da Java.util.Anche i tuoi tipi, quindi, possono essere utilizzati con questa sintassi.
IL foreach ciclo continuo, aggiunto Giava5 (chiamato anche "ciclo for avanzato"), equivale a utilizzare a java.util.Iterator--è zucchero sintattico per la stessa cosa.Pertanto, leggendo ciascun elemento, uno per uno e in ordine, a foreach dovrebbe sempre essere scelto rispetto a un iteratore, poiché è più conveniente e conciso.
per ciascuno
for(int i : intList) {
System.out.println("An element in the list: " + i);
}
Iteratore
Iterator<Integer> intItr = intList.iterator();
while(intItr.hasNext()) {
System.out.println("An element in the list: " + intItr.next());
}
Ci sono situazioni in cui è necessario utilizzare un file Iterator direttamente.Ad esempio, tentando di eliminare un elemento mentre si utilizza a foreach può (sarà?) risultare in a ConcurrentModificationException.
foreach contro for:Differenze fondamentali
L'unica differenza pratica tra for E foreach è che, nel caso di oggetti indicizzabili, non si ha accesso all'indice.Un esempio quando il basic for il ciclo è richiesto:
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 di indice separata con foreach,
int idx = -1;
for(int i : intArray) {
idx++;
...
}
non è raccomandato, poiché ambito variabile non è l'ideale, e la base for loop è semplicemente il formato standard e previsto per questo caso d'uso.
foreach contro for:Prestazione
Quando si accede alle raccolte, a foreach È significativamente più veloce rispetto a quello di base for accesso all'array del loop.Quando si accede agli array, tuttavia, almeno con gli array primitivi e wrapper, l'accesso tramite indici è notevolmente più veloce.
Tempistica della differenza tra l'iteratore e l'accesso all'indice per gli int-array primitivi
Gli indici sono 23-40 percentuale più veloce degli iteratori durante l'accesso int O Integer matrici.Ecco l'output della classe testing in fondo a questo post, che somma i numeri in un array primitive-int di 100 elementi (A è l'iteratore, B è 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)
L'ho eseguito anche per un Integer array e gli indici sono ancora il chiaro vincitore, ma solo tra il 18 e il 25% più veloci.
Per le raccolte, gli iteratori sono più veloci degli indici
Per un List Di Integers, tuttavia, gli iteratori sono il chiaro vincitore.Basta cambiare l'int-array nella classe-test in:
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 apportare le modifiche necessarie alla funzione test (int[] A List<Integer>, length A size(), eccetera.):
[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 si basa su due risposte che ho scritto su Stack Overflow:
Qualche informazione in più: Qual è più efficiente, un ciclo for-each o un iteratore?
L'intera lezione di prova
Ho creato questa lezione sul confronto del tempo necessario per fare due cose qualsiasi dopo aver letto questa domanda sullo 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 degli iteratori Java.È meno preciso, ma è utile per l’istruzione.
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 di scrivere questo modello comune in un modo più naturale e meno rumoroso dal punto di vista sintattico.
for(char grade : grades) { // foreach grade in grades
System.out.print(grade); // print that grade
}
Inoltre questa sintassi è valida per oggetti come Lists o Sets che non supportano l'indicizzazione degli 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à 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 nella risposta di nsayer, ma vale la pena notare che la sintassi for(..) dell'OP funzionerà quando "someList" è nulla che implementa java.lang.Iterable: non deve essere un elenco o una raccolta da java.util.Anche i tuoi tipi, quindi, possono essere utilizzati 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
AVVERTIMENTO:Puoi accedere agli elementi dell'array con il ciclo foreach, ma NON puoi inizializzarli.Usa l'originale for loop per quello.
AVVERTIMENTO:È necessario far corrispondere il tipo dell'array con l'altro oggetto.
for (double b:s) // Invalid-double is not String
Se vuoi modificare gli elementi, usa l'originale for loop 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 i file sulla console, otteniamo:
hello
2 is cool
hello
hello
Come definito in JLS for-each loop può avere due forme:
Se il tipo di Expression è un sottotipo di
Iterableallora 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); }Se l'espressione ha necessariamente un tipo array
T[]Poi: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 flussi che funzionano generalmente meglio.Possiamo usarli come:
someList.stream().forEach(System.out::println);
Arrays.stream(someArray).forEach(System.out::println);
Il costrutto del ciclo Java "for-each" consentirà l'iterazione su due tipi di oggetti:
T[](array di qualsiasi tipo)java.lang.Iterable<T>
IL Iterable<T> l'interfaccia ha un solo metodo: Iterator<T> iterator().Funziona su oggetti di tipo Collection<T> perché il Collection<T> l'interfaccia si estende Iterable<T>.
Il concetto di ciclo foreach menzionato in Wikipedia è evidenziato di seguito:
A differenza di altri costrutti per loop, tuttavia, di solito i loop di forea nessun contatore esplicito:In sostanza dicono "fai questo a tutto in questo set", piuttosto che "fare questo x tempi".Questo evita il potenziale errori uno dopo l'altro e rende il codice più semplice da leggere.
Quindi il concetto di ciclo foreach descrive che il ciclo non utilizza alcun contatore esplicito, il che significa che non è necessario utilizzare indici per attraversare l'elenco, quindi salva l'utente da errori 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 utilizzando 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 l'elenco inizia con l'indice 1, questo ciclo genererà un'eccezione poiché non troverà alcun elemento nell'indice 0 e questo errore è chiamato errore off-by-one.Quindi, per evitare questo errore off-by-one, viene utilizzato il concetto di ciclo foreach.Potrebbero esserci anche altri vantaggi, ma questo è quello che penso sia il concetto principale e il vantaggio dell'utilizzo di un ciclo foreach.
for (Iterator<String> itr = someList.iterator(); itr.hasNext(); ) {
String item = itr.next();
System.out.println(item);
}
Ecco un'espressione equivalente.
for(Iterator<String> sit = someList.iterator(); sit.hasNext(); ) {
System.out.println(sit.next());
}
Tieni inoltre presente che l'utilizzo del metodo "foreach" nella domanda originale presenta alcune limitazioni, come l'impossibilità di rimuovere elementi dall'elenco durante l'iterazione.
Il nuovo ciclo for è più facile da leggere ed elimina la necessità di un iteratore separato, ma è realmente utilizzabile solo nei passaggi di iterazione di sola lettura.
Utilizzando versioni Java precedenti incluse Java 7 Puoi usare foreach eseguire il ciclo 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 utilizzo foreach entrare in loop Java 8
(riesegui il ciclo di un elenco 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 consultare questo collegamento.
Un'alternativa a forEach per evitare il tuo "for ciascuno":
List<String> someList = new ArrayList<String>();
Variante 1 (semplice):
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 tutta la confusione di base del loop.Dà un aspetto pulito al tuo codice, giustificato di seguito.
Normale for ciclo continuo:
void cancelAll(Collection<TimerTask> list) {
for (Iterator<TimerTask> i = list.iterator(); i.hasNext();)
i.next().cancel();
}
Utilizzando per ciascuno:
void cancelAll(Collection<TimerTask> list) {
for (TimerTask t : list)
t.cancel();
}
per ciascuno è un costrutto su una raccolta che implementa Iteratore.Ricordalo, la tua collezione dovrebbe essere implementata Iteratore;altrimenti non puoi usarlo con for-each.
La riga seguente viene letta come "per ogni TimerTask t nell'elenco."
for (TimerTask t : list)
C'è meno possibilità di errori in caso di for-each.Non devi preoccuparti di inizializzare l'iteratore o di inizializzare il contatore del ciclo e terminarlo (dove c'è spazio per errori).
In Java 8, hanno introdotto forEach.Usandolo Elenco, le mappe possono essere ripetute in loop.
Ripeti un elenco utilizzando for ciascuno
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);
});
Ripeti una mappa utilizzando per ciascuno
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);
});
Sembrerebbe qualcosa del genere.Molto cruento.
for (Iterator<String> i = someList.iterator(); i.hasNext(); )
System.out.println(i.next());
C'è un buon articolo su per ciascuno nel Documentazione solare.
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 puoi fare la stessa cosa con molta meno sintassi.Ad esempio, per il tuo someList tu puoi fare:
someList.stream().forEach(System.out::println);
Puoi trovare ulteriori informazioni sugli stream Qui.
Come hanno detto tante buone risposte, un oggetto deve implementare il file Iterable interface se vuole usare a for-each ciclo continuo.
Pubblicherò un semplice esempio e cercherò di spiegare in modo diverso come a for-each il ciclo funziona.
IL for-each esempio di ciclo:
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 javap per decompilare questa classe, otterremo questo esempio di 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 dell'esempio, il compilatore convertirà automaticamente l'uso di for-each parola chiave per l'uso di an Iterator in fase di compilazione.Ciò potrebbe spiegare perché object, che non implementa il file Iterable interface, lancerà un Exception quando tenta di utilizzare il file for-each ciclo continuo.
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 ciclo for migliorato) è una versione semplificata di un ciclo for.Il vantaggio è che c’è meno codice da scrivere e meno variabili da gestire.Lo svantaggio è che non hai alcun controllo sul valore del passo e nessun accesso all'indice del loop all'interno del corpo del loop.
Sono utilizzati al meglio quando il valore del passo è un semplice incremento di 1 e quando è necessario accedere solo all'elemento del ciclo corrente.Ad esempio, se è necessario eseguire il loop su ogni elemento di un array o di una Collection senza sbirciare davanti o dietro l'elemento corrente.
Non esiste alcuna 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 dei normali cicli for.
I cicli for avanzati seguono questo ordine di esecuzione:
1) corpo dell'anello
2) ripetere dal passaggio 1 finché non è stato attraversato l'intero array o raccolta
Esempio: array di numeri interi
int [] intArray = {1, 3, 5, 7, 9};
for(int currentValue : intArray) {
System.out.println(currentValue);
}
La variabile currentValue contiene il valore corrente in loop nell'array intArray.Nota che non esiste un valore di passo esplicito: è sempre un incremento di 1.
Si può pensare che i due punti significhino "dentro".Quindi la dichiarazione del ciclo for potenziato afferma:eseguire il loop su intArray e memorizzare il valore int dell'array corrente In la variabile ValoreCorrente.
Produzione:
1
3
5
7
9
Esempio: matrice di stringhe
Possiamo usare il ciclo for-each per scorrere un array di stringhe.La dichiarazione del ciclo afferma:esegue il loop sull'array di stringhe myStrings e memorizza il valore String 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 migliorato può essere utilizzato anche per scorrere 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 afferma:esegue il loop su myList Elenco di stringhe e memorizza il valore dell'elenco corrente In la variabile oggetto corrente.
Produzione:
alpha
beta
gamma
delta
Esempio – Imposta
Il ciclo for migliorato può essere utilizzato anche per scorrere 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 afferma:esegue il loop su mySet Set di stringhe e memorizza il valore Set corrente In la variabile oggetto corrente.Si noti che poiché si tratta di un Set, i valori String duplicati non vengono archiviati.
Produzione:
alpha
delta
beta
gamma
L'idioma Java per ogni può essere applicato solo ad array o oggetti di tipo *Iterabile.Questo idioma è implicito poiché è veramente supportato da un Iterator.L'Iterator è programmato dal programmatore e spesso utilizza un indice intero o un nodo (a seconda della struttura dei dati) per tenere traccia della sua posizione.Sulla carta è più lento di un normale ciclo for, almeno per strutture "lineari" come array e liste, ma fornisce una maggiore astrazione.
Sembra pazzesco ma ehi, funziona
List<String> someList = new ArrayList<>(); //has content
someList.forEach(System.out::println);
Funziona. Magia
List<Item> Items = obj.getItems();
for(Item item:Items)
{
System.out.println(item);
}
Itera su tutti gli oggetti nella tabella Articoli.
