Come funziona il ciclo Java "for each"?
-
01-07-2019 - |
Domanda
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
Iterable
allora 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.