Wie funktioniert das Java 'für jede' Schleife arbeiten?

Question

Beachten:

List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList

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

Was wäre das äquivalent for Schleife Aussehen, ohne Verwendung der für jedes syntax?

Answer 1

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

Beachten Sie, wenn Sie i.remove(); in der Schleife verwenden müssen, oder die tatsächliche Iterator in irgendeiner Weise zugreifen können, nicht die for ( : ) Idiom verwenden können, da die tatsächliche Iterator nur geschlossen wird.

Wie von Denis Bueno bemerkt wurde, funktioniert dieser Code für jedes Objekt, das die Iterable Schnittstelle .

Auch wenn die rechte Seite des for (:) Idiom ein array eher als ein Iterable Objekt ist, der interne Code verwendet einen int Indexzähler und prüft gegen array.length statt. Sehen Sie sich die Java Language Specification .

Answer 2

Das Konstrukt für jeden für Arrays auch gültig ist. z.

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

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

, die im Wesentlichen äquivalent ist der

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

Also, insgesamt Zusammenfassung:
[nsayer] Hier finden Sie die längere Form dessen, was geschieht:

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

     

Beachten Sie, wenn Sie verwenden müssen   ich entferne(); in der Schleife oder den Zugang   die tatsächliche Iterator in irgendeiner Weise, Sie   (:) Nicht die für verwenden Idiom, da   die tatsächliche Iterator ist nur   inferred.

[Denis Bueno]

  

Es ist implizierten nsayer Antwort, aber   es ist erwähnenswert, dass die OP ist für (..)   Syntax wird funktionieren, wenn „someList“ ist   Alles, was Geräte   java.lang.Iterable - es hat nicht   eine Liste, oder eine Sammlung zu sein von   java.util. Auch Ihre eigenen Arten,   Daher kann mit diesem verwendet werden   Syntax.

Answer 3

Die foreach loop, Hinzugefügt in Java 5 (auch als "enhanced for loop") entspricht bei Verwendung eines java.util.Iterator- es ist syntaktischer Zucker für die gleiche Sache.Also, beim Lesen jedes element einzeln und in der gewünschten Reihenfolge ein foreach sollte immer gewählt werden, über einen iterator, wie es ist mehr bequem und prägnant.

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

Es gibt Situationen, in denen müssen Sie ein Iterator direkt.Wenn Sie beispielsweise versuchen um ein element zu löschen, während Sie ein foreach kann (wird?) Ergebnis in einem ConcurrentModificationException.

foreach vs. for:Grundlegende Unterschiede

Der einzige praktische Unterschied zwischen for und foreach ist, dass, im Fall von Wendeplatten-Objekte, die Sie nicht haben Zugriff auf den index.Ein Beispiel, wenn die grundlegenden for Schleife erforderlich ist:

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

Sie können zwar manuell erstellen Sie einen separaten index int-variable mit foreach,

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

es wird nicht empfohlen, da variable-scope ist nicht ideal, und die grundlegenden for Schleife ist einfach der standard-und der erwartete format für diesen Anwendungsfall.

foreach vs. for:Leistung

Beim Zugriff auf Sammlungen, foreach ist deutlich schneller als die grundlegende for Schleife das array zugreifen.Beim Zugriff auf arrays, aber-zumindest mit primitiven wrapper-arrays-Zugriff über Indizes, die dramatisch schneller.

Timing der Unterschied zwischen iterator und index-Zugriff für primitive int-arrays

Indizes sind 23-40 Prozent schneller als Iteratoren beim Zugriff auf int oder Integer arrays.Hier ist die Ausgabe der Tests Klasse an der Unterseite von diesem post, der die Summe der zahlen in einer 100-element primitive-int-array ist Ein iterator, B, index):

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 358,597,622 nanoseconds
Test B: 269,167,681 nanoseconds
B faster by 89,429,941 nanoseconds (24.438799231635727% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 377,461,823 nanoseconds
Test B: 278,694,271 nanoseconds
B faster by 98,767,552 nanoseconds (25.666236154695838% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 288,953,495 nanoseconds
Test B: 207,050,523 nanoseconds
B faster by 81,902,972 nanoseconds (27.844689860906513% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,373,765 nanoseconds
Test B: 283,813,875 nanoseconds
B faster by 91,559,890 nanoseconds (23.891659337194227% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,790,818 nanoseconds
Test B: 220,770,915 nanoseconds
B faster by 155,019,903 nanoseconds (40.75164734599769% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 326,373,762 nanoseconds
Test B: 202,555,566 nanoseconds
B faster by 123,818,196 nanoseconds (37.437545972215744% faster)

Ich lief auch dieses für ein Integer array, und die Indizes sind immer noch die klaren Gewinner, aber nur zwischen 18 und 25 Prozent schneller.

Für collections, Iteratoren sind schneller als Indizes

Für eine List von Integers, jedoch, Iteratoren sind die klaren Gewinner.Ändern Sie einfach die int-array in der test-Klasse:

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

Und nehmen Sie die notwendigen änderungen an der test-Funktion (int[] zu List<Integer>, length zu 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)

In einem test sind Sie fast gleichwertig, aber mit Sammlungen, iterator gewinnt.

*Dieser Beitrag basiert auf zwei Antworten, die ich schrieb auf Stack-Überlauf:

• Verwendet und die syntax für die for-each-Schleife in Java

• Sollte ich einen Iterator oder einen forloop zu Durchlaufen?

Einige mehr Informationen: Was ist effizienter, eine für jede Schleife oder ein iterator?

Der vollständige Test-Klasse

Ich habe diesen Vergleich-der-Zeit-ist-es-dauert-sind-alle-zwei-Dinge-Klasse nach der Lektüre diese Frage auf 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

}

Answer 4

Hier ist eine Antwort, die keine Kenntnisse über Java-Iteratoren voraussetzt.Es ist weniger präzise, ​​aber für die Bildung nützlich.

Beim Programmieren schreiben wir oft Code, der wie folgt aussieht:

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]
}

Die foreach-Syntax ermöglicht es, dieses allgemeine Muster auf eine natürlichere und weniger syntaktisch verrauschte Weise zu schreiben.

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

Darüber hinaus gilt diese Syntax für Objekte wie Listen oder Mengen, die keine Array-Indizierung unterstützen, aber die Java Iterable-Schnittstelle implementieren.

Answer 5

Die for-each-Schleife in Java verwendet den zugrundeliegenden Mechanismus Iterator. Es ist also identisch mit dem folgenden:

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

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

Answer 6

In Java 8-Funktionen können Sie verwenden:

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

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

Output

First
Second
Third

Answer 7

Es ist von nsayer Antwort impliziert, aber es ist erwähnenswert, dass die OP ist für (..) Syntax wird funktionieren, wenn „someList“ ist alles , die implementiert java.lang.Iterable - es funktioniert nicht hat eine Liste sein, oder eine Sammlung von java.util. Auch Ihre eigenen Typen können daher mit dieser Syntax verwendet werden.

Answer 8

A foreach Schleife Syntax lautet:

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

Beispiel:

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

Ausgabe:

Java
Coffe
Is
Cool

ACHTUNG: Sie können Array-Elemente mit der foreach-Schleife zugreifen, aber man kann sich nicht initialisiert werden. Verwenden Sie die Original for Schleife dafür.

. WARNUNG: Sie müssen den Typ des Arrays mit dem anderen Objekt übereinstimmen

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

Wenn Sie Elemente bearbeiten möchten, verwenden Sie die Original-for Schleife wie folgt:

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

Nun, wenn wir s an die Konsole Dump, erhalten wir:

hello
2 is cool
hello
hello

Answer 9

Wie definiert in JLS -jeder Schleife zwei Formen haben:

1. Wenn die Art der Expression ein Subtyp von Iterable ist dann Übersetzung ist wie:

   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. Wenn der Ausdruck notwendigerweise ein Array-Typ T[] dann:

   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 hat Ströme eingeführt, die im Allgemeinen eine bessere Leistung. Wir können sie als verwenden:

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

Answer 10

Die Java "for-each" Schleifenkonstrukt Iteration über zwei Arten von Objekten erlauben:

• T[] (Arrays jeglicher Art)
• java.lang.Iterable<T>

Die Iterable<T> Schnittstelle hat nur eine Methode: Iterator<T> iterator(). Dies funktioniert auf Objekte vom Typ Collection<T> weil die Collection<T> Schnittstelle erweitert Iterable<T>.

Answer 11

Das Konzept einer foreach-Schleife wie in Wikipedia erwähnt wird im Folgenden erläutert:

  

Im Gegensatz zu anderen für Schleifenkonstrukte jedoch foreach-Schleifen in der Regel   pflegen keine expliziten Zähler : sie im Wesentlichen „, sagt dies tun, um   alles in diesem Satz“, sondern als‚tut dies x-mal‘. Dadurch wird vermieden,   Potential Off-by-one Fehler und macht Code einfacher zu lesen.

So das Konzept einer foreach-Schleife beschreibt, dass die Schleife keine expliziten Zähler nicht verwendet, was bedeutet, dass es keine Notwendigkeit gibt, Indizes der Verwendung in der Liste zu durchqueren, so speichert es Benutzer von Off-by-one Fehlern. Um das allgemeine Konzept dieser Off-by-one Fehler zu beschreiben, lassen Sie uns ein Beispiel für eine Schleife, um in einer Liste durchqueren mit Indizes.

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

}

Aber nehmen wir an, wenn die Liste beginnt mit Index 1 dann diese Schleife wird eine Ausnahme ausgelöst, da es kein Element bei Index 0 und dieser Fehler gefunden wird, ist ein Off-by-one Fehler genannt. So vermeiden Sie diese Off-by-one Fehler das Konzept einer foreach-Schleife verwendet wird. Es können auch andere Vorteile, aber das ist, was ich denke, das wichtigste Konzept ist und Vorteil einer foreach-Schleife.

Answer 12

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

Answer 13

Hier ist ein äquivalenter Ausdruck.

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

Answer 14

Beachten Sie auch, dass die „foreach“ -Methode in der ursprünglichen Frage mit einigen Einschränkungen hat, wie zum Beispiel nicht in der Lage Elemente aus der Liste während der Iteration zu entfernen.

Die neue for-Schleife ist leichter zu lesen und beseitigt die Notwendigkeit für einen separaten Iterator, ist aber nur dann wirklich brauchbar in Nur-Lese-Iteration hindurchgeht.

Answer 15

Mit älteren Java-Versionen einschließlich Java 7 Sie foreach Schleife verwenden können wie folgt.

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

Im Anschluss ist die neueste Art und Weise foreach Schleife in Java 8 der mit

(loop eine Liste mit dem forEach + Lambda-Ausdruck oder Methode Referenz)

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

Für mehr Informationen zu diesem Link verweisen.

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

Answer 16

Eine Alternative zu forEach, um zu vermeiden, dass Ihre "für jeden":

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

Variante 1 (Ebene):

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

Variante 2 (parallele Ausführung (schneller)):

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

Answer 17

Es fügt Schönheit Ihrem Code durch alle grundlegenden Looping Unordnung zu entfernen. Es gibt einen sauberen Blick auf den Code, gerechtfertigt unten.

Normale for Schleife:

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

Verwendung von for-each:

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

for-each ist ein Konstrukt, über eine Sammlung, die Arbeitsgeräte Iterator . Denken Sie daran, dass, sollten Sie Ihre Sammlung implementieren Iterator ; sonst kann man es nicht mit for-each verwenden.

Die folgende Zeile wird gelesen als " für jeden Timertask t in der Liste. "

for (TimerTask t : list)

Es gibt weniger Chancen für Fehler bei for-each. Sie müssen sich keine Sorgen über den Iterator Initialisierung oder der Schleifenzähler initialisiert und beendet sie (wo es Raum für Fehler).

Answer 18

In Java 8, sie eingeführt forEach. Mit ihm Liste können Karten durchgeschleift werden.

Schleife eine Liste mit für jeden

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

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

oder

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

Schleife eine Karte mit für jeden

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

oder

mapList.forEach((key,value)->{
    System.out.println("Key : " + key + " Value : " + value);
});

Answer 19

Es wäre etwa so aussehen. Sehr crufty.

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

Es gibt eine gute Zuschreibung auf für jeden in Sun Dokumentation .

Answer 20

Vor Java 8, müssen Sie die folgende verwenden:

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

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

Doch mit der Einführung von Streams in Java 8 Sie können in viel weniger Syntax gleiche tun. Zum Beispiel für Ihre someList können Sie tun:

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

Sie können mehr über Streams finden hier .

Answer 21

Wie so viele gute Antworten gesagt, ein Objekt muss die Iterable interface implementieren, wenn es will eine for-each Schleife verwenden.

Ich werde ein einfaches Beispiel posten und versuchen, in einer anderen Art und Weise zu erklären, wie ein for-each Schleife funktioniert.

Das for-each Schleife Beispiel:

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

Wenn wir dann javap verwenden diese Klasse zu dekompilieren, werden wir diese Bytecode-Probe erhalten:

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;

Wie wir aus der letzten Zeile der Probe sehen können, wird der Compiler automatisch die Verwendung von for-each Schlüsselwort auf die Verwendung eines Iterator bei der Kompilierung konvertieren. Das mag erklären, warum Objekt, das nicht die Iterable interface nicht implementiert, wird ein Exception werfen, wenn es versucht, die for-each Schleife zu verwenden.

Answer 22

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

Answer 23

Die Java für jede Schleife (auch bekannt als for-Schleife erweitert) ist eine vereinfachte Version einer for-Schleife. Der Vorteil besteht darin, dass es weniger Code zu schreiben und weniger Variablen zu verwalten. Der Nachteil ist, dass Sie keine Kontrolle über den Schrittwert und keinen Zugriff auf den Schleifenindex innerhalb der Schleife haben.

Sie werden am besten verwendet, wenn der Schrittwert ein einfacher Zuwachs von 1 ist, und wenn Sie nur der Zugriff auf die Stromschleife Element benötigen. wenn Sie beispielsweise jedes Element eine Schleife über die in einem Array oder Sammlung ohne spähen vor oder hinter dem aktuellen Element.

Es gibt keine Schleife Initialisierung kein boolean Zustand und der Schrittwert ist implizit und ist eine einfache Erhöhung. Dies ist, warum sie so viel einfacher als regelmäßiges for-Schleifen berücksichtigt werden.

Erweitert für Schleifen diese Reihenfolge der Ausführung wie folgt vor:

1) Schleifenkörper

2) Wiederholen von Schritt 1, bis gesamte Array oder eine Sammlung durchlaufen wurde

Beispiel - Integer Array

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

Die current Variable enthält den aktuellen Wert in dem Array intArray geschleift über wird. Beachten Sie, es gibt keine expliziten Schritt Wert -. Es ist immer ein Zuwachs von 1

kann der Doppelpunkt gedacht werden bedeuten „in“. So ist die verbesserte for-Schleife Erklärung heißt es:. Schleife über intArray und speichern Sie die aktuelle Array int-Wert die Variable current

Ausgabe:

1
3
5
7
9

Beispiel - String Array

Wir verwenden für-jede Schleife ein Array von Strings iterieren. Die Schleifen Erklärung Zustände: Schleife über myStrings String-Array und Speichern der aktuellen String-Wert die currentString variable

.

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

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

Ausgabe:

alpha
beta
gamma
delta

Beispiel - Liste

Die erweiterte for-Schleife kann auch ein java.util.List iterieren wie folgt verwendet werden:

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

Die Schleife Erklärung heißt es:. Schleife über myList Liste der Strings und speichern Sie die aktuelle Liste Wert die currentItem Variable

Ausgabe:

alpha
beta
gamma
delta

Beispiel - Set

Die erweiterte for-Schleife kann auch ein java.util.Set iterieren wie folgt verwendet werden:

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

Die Schleife Erklärung heißt es: Schleife über MYSET Satz von Strings und speichern Sie die aktuellen Sollwert die currentItem Variable. Beachten Sie, dass da dies ein Set ist, doppelte String-Werte nicht gespeichert werden.

Ausgabe:

alpha
delta
beta
gamma

Quelle: Loops in Java - Ultimate Guide

Answer 24

Die Java-for-each Idiom kann nur auf Arrays oder Objekte des Typs angewendet werden * Iterable . Dieses Idiom ist implizite , wie es wirklich von einem Iterator gesichert. Der Iterator wird vom Programmierer programmiert und verwendet häufig einen ganzzahligen Index oder einen Knoten (abhängig von der Datenstruktur) Spur seiner Position zu halten. Auf dem Papier ist es langsamer als eine normale for-Schleife, ein dest für „linear“ Strukturen wie Arrays und Listen, aber es bietet eine größere Abstraktion.

Answer 25

Das sieht verrückt, aber hey es funktioniert

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

Das funktioniert. Magie

Answer 26

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

Iteriert über alle Objekte in Tabelle Artikel.