it-swarm-eu.dev

Jak funguje Java pro každou smyčku?

Zvážit:

List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList
for (String item : someList) {
    System.out.println(item);
}

Jak by vypadala ekvivalentní smyčka for bez použití pro každou syntaxi?

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

Všimněte si, že pokud potřebujete použít i.remove(); ve vaší smyčce, nebo nějakým způsobem přistupovat ke skutečnému iterátoru, nemůžete použít for ( : ) idiom, protože skutečný iterátor je pouze odvozen.

Jak poznamenal Denis Bueno, tento kód funguje pro všechny objekty, které implementují rozhraní Iterable .

Pokud je pravá strana for (:) idiom objektem array místo objektu Iterable, interní kód používá čítač int indexu a místo toho kontroluje proti array.length. Viz Specifikace jazyka Java .

1090
nsayer

Konstrukce pro každý platí také pro pole. např.

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

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

který je v podstatě ekvivalentní

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

Celkové shrnutí:
[nsayer] Následující je delší forma toho, co se děje:

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

Všimněte si, že pokud potřebujete použít i.remove (); ve vaší smyčce, nebo nějakým způsobem přistupovat ke skutečnému iterátoru, nemůžete použít id pro (:), protože skutečný Iterator je pouze odvozen.

[Denis Bueno]

To je implikováno odpovědí nsayer, ale stojí za zmínku, že OP pro (..) syntaxi bude fungovat, když "someList" je něco, co implementuje Java.lang.Iterable - nemusí to být seznam nebo nějaká kolekce z Java.util. S touto syntaxí lze tedy použít i vaše vlastní typy.

464
Mikezx6r

foreach smyčka , přidaná v Java 5 (také nazývaná "vylepšená pro smyčku"), je ekvivalentní použití Java.util.Iterator - syntaktického cukru pro totéž. Proto při čtení každého prvku, jeden po druhém a v pořadí, by foreach mělo být vždy vybráno přes iterátor, protože je výhodnější a stručnější.

pro každého

for(int i : intList) {
   System.out.println("An element in the list: " + i);
}

Iterátor

Iterator<Integer> intItr = intList.iterator();
while(intItr.hasNext()) {
   System.out.println("An element in the list: " + intItr.next());
}

Jsou situace, kdy musíte použít Iterator přímo. Například pokus o odstranění prvku při použití foreach může (bude?) Vést k ConcurrentModificationException.

foreach vs. for: Základní rozdíly

Jediný praktický rozdíl mezi for a foreach je, že v případě indexovatelných objektů nemáte přístup k indexu. Příklad, kdy je požadována základní smyčka for:

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

Přestože můžete ručně vytvořit samostatnou proměnnou indexu int s proměnnou foreach,

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

není doporučeno, protože variable-scope není ideální, a základní for smyčka je jednoduše standard a očekávaný formát pro tento případ použití.

foreach vs. for: Výkon

Při přístupu ke sbírkám je foreachvýrazně rychlejší než základní přístup k matici for loop. Při přístupu k polím - alespoň s primitivním a wrapperovým polem - je přístup přes indexy výrazně rychlejší.

Načasování rozdílu mezi iterátorem a přístupem indexu pro primitivní int-pole

Indexy jsou 23 - 40 procent rychlejší než iterátory při přístupu k souborům int nebo Integer. Zde je výstup z testovací třídy v dolní části tohoto příspěvku, který sumarizuje čísla v 100-prvkovém primitivním-int pole (A je iterátor, B je 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)

Také jsem běžel to Integer pole a indexy jsou stále jasným vítězem, ale jen mezi 18 a 25 procent rychleji.

U sbírek jsou iterátory rychlejší než indexy

Pro ListIntegers, nicméně, iterátory jsou jasným vítězem. Stačí změnit int-array v testovací třídě na:

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

Proveďte nezbytné změny testovací funkce (int[] na List<Integer>, length na size() atd.):

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

V jednom testu jsou téměř rovnocenné, ale se sbírkami vyhrává iterátor.

* Tento příspěvek je založen na dvou odpovědích, které jsem napsal na přetečení zásobníku:

Některé další informace:Co je efektivnější, pro každou smyčku nebo iterátor?

Plná testovací třída

Po přečtení této otázce na přetečení zásobníku: jsem vytvořil tuto třídu třídy porovnání času-it-take-to-do-any-two-things.

import  Java.text.NumberFormat;
import  Java.util.Locale;

/**
   &lt;P&gt;{@code Java TimeIteratorVsIndexIntArray 1000000}&lt;/P&gt;

   @see  &lt;CODE&gt;&lt;A HREF=&quot;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-Java&quot;&gt;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-Java&lt;/A&gt;&lt;/CODE&gt;
 **/
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

}
141
aliteralmind

Zde je odpověď, která nepředpokládá znalost Java Iterátorů. Je to méně přesné, ale je užitečné pro vzdělávání.

Při programování často píšeme kód, který vypadá takto:

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

Syntaxe foreach umožňuje, aby tento společný vzor byl psán přirozenějším a méně syntakticky hlučným způsobem.

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

Tato syntaxe je navíc platná pro objekty, jako jsou seznamy nebo sady, které nepodporují indexování matic, ale které implementují rozhraní Java Iterable.

125
MRocklin

For-každá smyčka v Javě používá podkladový iterátorový mechanismus. Je tedy totožné s následujícími:

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

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

Ve funkcích Java 8 můžete použít toto:

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

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

Výstup

First
Second
Third
23
Jrovalle

To je implikováno odpovědí nsayer, ale stojí za zmínku, že OP pro (..) syntaxi bude fungovat, když "someList" je něco který implementuje Java.lang.Iterable - nemusí to být seznam, nebo nějakou sbírku z Java.util. S touto syntaxí lze tedy použít i vaše vlastní typy.

22
EfForEffort

Syntaxe smyčky foreach je:

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

Příklad:

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

Výstup:

Java
Coffe
Is
Cool

UPOZORNĚNÍ: K prvkům matice můžete přistupovat smyčkou foreach, ale nelze je inicializovat. Použijte původní smyčku for.

Upozornění: Musíte odpovídat typu pole s jiným objektem.

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

Chcete-li upravit prvky, použijte původní smyčku for takto:

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

Pokud nyní vypíšeme konzolu, dostaneme:

hello
2 is cool
hello
hello
21
PrivateName

Konstrukce smyčky Java "for-each" umožní iteraci přes dva typy objektů:

  • T[] (pole libovolného typu)
  • Java.lang.Iterable<T>

Rozhraní Iterable<T> má pouze jednu metodu: Iterator<T> iterator(). Toto funguje na objektech typu Collection<T>, protože rozhraní Collection<T> rozšiřuje Iterable<T>.

20
Ryan Delucchi

Jak je definováno v JLS for-každá smyčka může mít dvě formy:

  1. Pokud je typ výrazu podtypem Iterable, překlad je následující:

    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. Pokud má výraz nutně typ pole T[], pak:

    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 zavedla toky, které fungují obecně lépe. Můžeme je použít jako:

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

Koncept smyčky foreach, jak je uvedeno v Wikipedii, je zdůrazněn níže:

Na rozdíl od jiných konstruktů smyčky však smyčky foreach obvykle udržují žádné explicitní počítadlo: v podstatě říkají "udělej to všem v této sadě", spíše než "udělej to x krát". Tím se vyhnete potenciálním chybám off-by-one a kód bude jednodušší ke čtení.

Takže koncept smyčky foreach popisuje, že smyčka nevyužívá žádné explicitní čítače, což znamená, že není nutné používat indexy pro procházení v seznamu, čímž se uživatel uloží z chyby off-by-one. Abychom popsali obecnou koncepci této chyby off-by-one, pojďme si vzít příklad smyčky, která by se pohybovala v seznamu pomocí indexů.

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

}

Předpokládejme však, že pokud seznam začíná indexem 1, bude tato smyčka hodit výjimku, protože v indexu 0 nenajde žádný prvek a tato chyba se nazývá chyba off-by-one. Abychom se vyhnuli této chybě off-by-one, je použita koncepce smyčky foreach. Mohou existovat i jiné výhody, ale myslím si, že je to hlavní koncept a výhoda použití smyčky foreach.

15
oneConsciousness

Všimněte si také, že použití metody "foreach" v původní otázce má určitá omezení, například není možné odebrat položky ze seznamu během iterace.

Nová smyčka for-loop je snazší číst a odstraňuje potřebu samostatného iterátoru, ale je skutečně použitelná pouze v iteračních průchodech pouze pro čtení.

9
billjamesdev

Pomocí starších verzí Java včetně Java 7 můžete použít smyčku foreach takto.

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

Následující je nejaktuálnější způsob použití foreach smyčky v Java 8

(smyčka seznamu s forEach + výrazem lambda nebo odkazem na metodu)

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

Pro více informací odkaz na tento odkaz.

https://www.mkyong.com/Java8/Java-8-foreach-examples/

9
Dulith De Costa

Tady je ekvivalentní výraz.

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

Alternativa k forEach, abyste se vyhnuli „za každého“:

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

Varianta 1 (prostá):

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

Varianta 2 (paralelní provedení (rychlejší)):

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

Přidává krásu do kódu tím, že odstraní všechny základní smyčky nepořádek. Dává čistý pohled na váš kód, zdůvodněný níže.

Normální smyčka for:

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

Použití pro každého:

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

for-each je konstrukce nad kolekcí, která implementuje Iterator . Nezapomeňte, že vaše sbírka by měla implementovat Iterator ; jinak ji nemůžete použít pro každého.

Následující řádek je čten jako " pro každý TimerTask t v seznamu. "

for (TimerTask t : list)

Tam je menší šance na chyby v případě pro-každý. Nemusíte se starat o inicializaci iterátoru nebo inicializaci počitadla smyčky a jeho ukončení (kde je prostor pro chyby).

7
Manohar

Vypadalo by to něco takového. Velmi krutý.

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

Existuje dobrý zápis na pro každou v dokumentaci Sun .

6
Pete

Před Java 8 musíte použít následující:

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

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

Nicméně, se zavedením Streams v Javě 8 můžete udělat totéž v mnohem menší syntaxi. Například pro someList můžete:

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

Více o streamech zde .

6
stackFan

Jak řeklo tolik dobrých odpovědí, objekt musí implementovat Iterable interface, pokud chce použít smyčku for-each.

Zveřejním jednoduchý příklad a pokusím se vysvětlit jiným způsobem, jak funguje smyčka for-each.

Příklad smyčky for-each:

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

Pokud použijeme javap k dekompilování této třídy, dostaneme tento vzorek 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;

Jak vidíme z posledního řádku vzorku, kompilátor automaticky převede použití klíčového slova for-each na použití Iterator při kompilaci. To může vysvětlit, proč objekt, který neprovede Iterable interface, hodí Exception, když se pokusí použít smyčku for-each.

5
L Joey

V jazyce Java 8 zavedli forEach. Pomocí tohoto seznamu lze Mapovat smyčky.

Seznam smyček pro každý

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

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

nebo

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

Loop a mapa s použitím

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

nebo

mapList.forEach((key,value)->{
    System.out.println("Key : " + key + " Value : " + value);
});
5
vivekkurien
public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
            for(int k=0;k<totalsize;k++)
            {
              fullst.addAll();
            }
}
3
Santhosh Rajkumar

Java pro každou smyčku (aka rozšířené pro smyčku) je zjednodušená verze smyčky for. Výhodou je, že je méně kódu pro zápis a méně proměnných pro správu. Nevýhodou je, že nemáte žádnou kontrolu nad hodnotou kroku a žádný přístup k indexu smyčky uvnitř těla smyčky.

Nejvhodnější je, když hodnota kroku je jednoduchý přírůstek 1 a když potřebujete pouze přístup k aktuálnímu prvku smyčky. Například, pokud potřebujete smyčku přes každý prvek v poli nebo Kolekci bez prohlížení dopředu nebo za aktuálním prvkem.

Neexistuje žádná inicializace smyčky, žádná logická podmínka a hodnota kroku je implicitní a je to jednoduchý přírůstek. To je důvod, proč jsou považovány za mnohem jednodušší než běžné pro smyčky.

Vylepšeno pro smyčky následuje toto pořadí provádění:

1) tělo smyčky

2) opakujte od kroku 1, dokud se neprojde celé pole nebo kolekce

Příklad - Integer Array

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

Proměnná currentValue uchovává aktuální hodnotu, která byla smyčkou převedena do pole intArray. Všimněte si, že neexistuje žádná explicitní hodnota kroku - je to vždy přírůstek o 1.

Dvojtečka může být považována za dvojtečku. Vylepšená deklarace pro smyčku tedy uvádí: loop over intArray a uloží aktuální hodnotu int int int in proměnná currentValue.

Výstup:

1
3
5
7
9

Příklad - Pole řetězce

Můžeme použít smyčku for-each k iteraci přes pole řetězců. Deklarace smyčky uvádí: loop over myStrings Pole String a uloží aktuální hodnotu String in the currentString.

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

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

Výstup:

alpha
beta
gamma
delta

Příklad - Seznam

Rozšířené smyčky lze také použít k iteraci přes Java.util.List následujícím způsobem:

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

Deklarace smyčky uvádí: loop over myList List of String a uloží aktuální hodnotu List in the currentItem variable.

Výstup:

alpha
beta
gamma
delta

Příklad - Nastavit

Rozšířené smyčky lze také použít k iteraci přes sadu Java.util.Set následujícím způsobem:

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

Deklarace smyčky uvádí: smyčku přes mySet Set of Strings a uloží aktuální hodnotu Set in the currentItem. Všimněte si, že toto je sada, duplicitní hodnoty řetězce nejsou uloženy.

Výstup:

alpha
delta
beta
gamma

Zdroj: Smyčky v Javě - Ultimate Guide

3
gomisha

Java pro každý idiom lze aplikovat pouze na pole nebo objekty typu * Iterable . Tento idiom je implicitní , protože je skutečně podpořen Iterátorem. Iterátor je programován programátorem a často používá celočíselný index nebo uzel (v závislosti na datové struktuře) pro sledování své pozice. Na papíře je pomalejší než běžná smyčka, alespoň pro "lineární" struktury, jako jsou pole a seznamy, ale poskytuje větší abstrakci.

2
WIll

To vypadá šíleně, ale funguje to

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

To funguje. Kouzlo

1
Rei Brown