Java 'onu biri için' nasıl çalışır?

Yapı her biri için ayrıca diziler için de geçerlidir. Örneğin.

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

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

hangi esas olarak eşdeğerdir

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

Yani, genel özeti:
[nsayer] Aşağıdakiler, olanların daha uzun şeklidir:

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

Not: i.remove () kullanmanız gerekirse; döngü'nüzde veya gerçek yineleyiciye bir şekilde erişirseniz, gerçek yineleyici yalnızca çıkarım olduğundan, for (:) deyimini kullanamazsınız.

[Denis Bueno]

Bu, nsayer'in cevabı tarafından ima edilir, ancak "someList", Java.lang'ı uygulayan herhangi bir şey olduğunda OP'nin (..) sözdiziminin işe yarayacağına dikkat çekmeye değer. Bir liste ya da bir koleksiyon olmak zorunda değildir. java.util. Bu nedenle, kendi türleriniz bile bu sözdizimiyle kullanılabilir.

Java 5 (ayrıca "döngü için geliştirilmiş" olarak da bilinir) ile eklenen foreachloop , Java.util.Iterator 'ı kullanmaya eşdeğerdir. aynı şey. Bu nedenle, her bir öğeyi tek tek ve sırayla okurken, daha uygun ve özlü olduğu için her zaman bir yineleyici üzerinde bir foreachseçilmelidir.

her biri için

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

Yineleyici

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

Doğrudan bir Iteratorkullanmanız gereken durumlar vardır. Örneğin, bir foreachkullanırken bir öğeyi silmeye çalışmak, bir ConcurrentModificationExceptionile sonuçlanabilir.

foreachvs. forname__: Temel farklar

forve foreacharasındaki tek pratik fark, endekslenebilir nesneler söz konusu olduğunda dizine erişiminizin olmamasıdır. Temel fordöngüsü gerekli olduğunda bir örnek:

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

foreachile int değişkenini ayrı bir dizin oluşturabilmenize rağmen,

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

değişken-kapsamı ideal olmadığından ve temel fordöngüsü bu kullanım durumu için standart ve beklenen format olduğundan, önerilmez.

foreachvs. forname__: Performans

Koleksiyonlara erişirken, bir foreachname__, temel fordöngüsünün dizi erişiminden, önemli ölçüde daha hızlı 'dır. Bununla birlikte, dizilere erişirken - en azından ilkel ve sarıcı dizilerle - dizinlerden erişim çok daha hızlıdır.

İlkel int diziler için yineleyici ve dizin erişimi arasındaki farkı zamanlama

Dizinler, intveya Integerdizilerine erişirken yineleyicilere göre yüzde 23 - 40 yüzdedir. İşte bu yazının altındaki test sınıfının çıktısı, 100 elemanlık bir ilkel-int dizisindeki sayıları (A yinelemeci, B dizinidir):

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

Bunu ayrıca bir Integerdizisi için koştum ve dizinler hala net kazanan, ancak yalnızca yüzde 18 ila 25 arasında daha hızlı.

Koleksiyonlarda, yineleyiciler dizinlerden daha hızlıdır

Ancak, ListIntegersiçin yinelenenler açık kazanandır. Test sınıfındaki int dizisini şu şekilde değiştirin:

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

Ve test işlevinde gerekli değişiklikleri yapın (int[] - List<Integer>, length- size(), vb.):

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

Bir testte neredeyse eşdeğerdirler, ancak koleksiyonlarda, yineleyici kazanır.

* Bu gönderi, Yığın Taşması ile ilgili yazdığım iki cevaba dayanıyor:

• JAVA'DAKI HER DÖNGÜ IÇIN KULLANIR VE SÖZDIZIMI

• TEKRARLAMAK IÇIN BIR YINELEYICI MI YOKSA BIR FORLOOP KULLANMALI MIYIM?

Bazı daha fazla bilgi:HANGISI DAHA VERIMLI, HER DÖNGÜ IÇIN, VEYA BIR YINELEYICI?

Tam test sınıfı

Yığın Taşması üzerine bu soru okuduktan sonra bu iki şeyi bir arada sınıfını oluşturdum.

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

}

Java yineleyicilerinin bilgisini almayan bir cevap. Daha az kesin, ancak eğitim için kullanışlıdır.

Programlama yaparken sıklıkla aşağıdakine benzeyen bir kod yazarız:

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

Foreach sözdizimi, bu ortak kalıbın daha doğal ve daha az sözdizimsel olarak gürültülü bir şekilde yazılmasını sağlar.

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

Ek olarak, bu sözdizimi, dizi indekslemeyi desteklemeyen, ancak Java Yinelenebilir arabirimini uygulayan Listeler veya Kümeler gibi nesneler için geçerlidir.

Java'daki her bir döngü, altta yatan yineleyici mekanizmasını kullanır. Yani aşağıdakilerle aynı:

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

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

Java 8'in özelliklerinde bunu kullanabilirsiniz:

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

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

Çıktı

First
Second
Third

Bu, nsayer'in cevabı tarafından ima edilir, ancak OP’nin (..) sözdiziminin "someList", Java.lang'ı uygulayan herhangi bir şey olduğunda işe yarayacağını belirtmekte fayda var - bir listesi veya Java.util'den bir koleksiyon. Bu nedenle, kendi türleriniz bile bu sözdizimiyle kullanılabilir.

Bir foreach döngüsü sözdizimi:

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

Örnek:

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

Çıktı:

Java
Coffe
Is
Cool

UYARI: Dizi elemanlarına foreach döngüsü ile erişebilirsiniz, ancak bunları başlatamazsınız. Bunun için orijinal for döngüsünü kullanın.

UYARI: Dizinin türünü diğer nesneyle eşleştirmelisiniz.

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

Öğeleri düzenlemek istiyorsanız, orijinal for döngüsünü şöyle kullanın:

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

Şimdi s'yi konsola dökersek, şunu elde ederiz:

hello
2 is cool
hello
hello

Java, "her biri için" döngü yapısı, iki tür nesne üzerinde yinelemeye izin verir:

• T[] (herhangi bir türdeki diziler)
• Java.lang.Iterable<T>

Iterable<T> arabiriminin yalnızca bir yöntemi vardır: Iterator<T> iterator(). Bu, Collection<T> türündeki nesnelerde çalışır, çünkü Collection<T> arabirimi, Iterable<T> öğesini genişletir.

JLS için-her bir döngü için iki şekilde olabilir:

1. İfade türü Iterable alt türü ise, çeviri aşağıdaki gibidir:

   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. İfade mutlaka T[] bir dizi türüne sahipse:

   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, genellikle daha iyi performans gösteren akışları sundu. Bunları şu şekilde kullanabiliriz:

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

Vikipedi'de belirtildiği gibi bir foreach döngüsü kavramı aşağıda vurgulanmıştır:

Bununla birlikte, döngü yapıları için diğerlerinden farklı olarak, foreach döngüleri genellikle açık sayaç yok sürdürürler: temel olarak "bu x zamanını yap" yerine "bunu bu kümedeki her şeye yap" derler. Bu, potansiyel tek tek hataları önler ve kodu okumayı kolaylaştırır.

Bu nedenle, bir foreach döngüsü konsepti, döngünün herhangi bir açık sayacı kullanmadığını, bu sayede listeyi dolaşmak için indeks kullanmanın gerekmediği anlamına gelir, böylece kullanıcıyı birer bir hatadan kurtarır. Bu tek tek hatanın genel kavramını açıklamak için, dizinleri kullanarak bir listede dolaşmak için bir döngü örneği ele alalım.

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

}

Ancak listenin 1. dizinle başlaması durumunda, bu döngünün, 0 dizininde hiçbir öğe bulamayacağı ve bu hataya bir hata olarak adlandırıldığı için bir istisna atacağını varsayalım. Dolayısıyla, bu bir-bir-hatadan kaçınmak için bir foreach döngüsü kavramı kullanılır. Başka avantajlar da olabilir ama bence bu bir foreach döngüsü kullanmanın ana konsepti ve avantajı.

Ayrıca, asıl soruda "foreach" yönteminin kullanılmasının, yineleme sırasında listedeki öğelerin kaldırılamaması gibi bazı sınırlamaları olduğunu unutmayın.

Yeni for döngüsü okumak kolaydır ve ayrı bir yineleyiciye olan ihtiyacı ortadan kaldırır, ancak yalnızca salt okunur yineleme işlemlerinde gerçekten kullanılabilir.

Java 7 dahil daha eski Java sürümlerini kullanarak, foreach döngüsünü aşağıdaki gibi kullanabilirsiniz.

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

Java 8 'da foreach loop kullanmanın en son yolu aşağıdadır

(forEach + lambda ifadesi veya yöntem referansı olan bir Listeyi döngü içine alın)

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

Daha fazla bilgi için bu bağlantıya bakın.

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

İşte eşdeğer bir ifade.

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

"Her biri için" olmaktan kaçınmak için forEach'e bir alternatif:

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

Değişken 1 (düz):

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

Değişke 2 (paralel yürütme (daha hızlı)):

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

Tüm temel döngü karmaşasını kaldırarak kodunuza güzellik katar. Aşağıda haklı olarak kodunuzu temiz bir görünüm verir.

Normal for loop:

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

Her birinin kullanımı:

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

her biri için, Yineleyici uygulayan bir koleksiyon üzerindeki yapıdır. Unutmayın, koleksiyonunuz Yineleyici; Aksi takdirde her biriyle kullanamazsınız.

Aşağıdaki satır, listedeki her TimerTask t için " olarak okunur. "

for (TimerTask t : list)

Her biri için hatalar için daha az şans vardır. Yineleyiciyi başlatma veya döngü sayacını başlatma ve sonlandırma konusunda endişelenmenize gerek yoktur (burada hataların kapsamı vardır).

Böyle bir şey olurdu. Çok crufty.

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

her biri için hakkında iyi bir yazı var Sun belgelerine .

Java 8'den önce, aşağıdakileri kullanmanız gerekir:

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

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

Ancak, Java 8'de Streams'ın eklenmesiyle aynı şeyi çok daha az sözdizimiyle yapabilirsiniz. Örneğin, someList'nız için şunları yapabilirsiniz:

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

Akışlar hakkında daha fazla bilgi bulabilirsiniz burada .

Pek çok iyi cevabın söylediği gibi, eğer bir nesne Iterable interface döngüsünü kullanmak istiyorsa, for-each 'u uygulamalıdır.

Basit bir örnek göndereceğim ve bir for-each döngüsünün nasıl çalıştığını farklı bir şekilde açıklamaya çalışacağım.

for-each döngü örneği:

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

Daha sonra, bu sınıfı bozmak için javap kullanırsak, bu bytecode örneğini alırız:

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;

Örneklemenin son satırından da görebileceğimiz gibi, derleyici, otomatik olarak for-each anahtar sözcüğünün kullanımını derleme zamanında bir Iterator kullanımına dönüştürür. Bu, Iterable interface öğesini uygulamayan nesnenin, for-each döngüsünü kullanmaya çalıştığında neden bir Exception atacağını açıklayabilir.

Java 8'de, Her bir için tanıttı. Listeyi kullanarak, Haritalar ilmeklenebilir.

Her birini kullanarak bir Listeyi döngü

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

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

veya

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

Her birini kullanarak bir Harita döngü

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

veya

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

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

Her döngü için Java (aka döngü için geliştirilmiş) for döngüsünün basitleştirilmiş bir versiyonudur. Bunun avantajı, yazmak için daha az kod ve yönetmek için daha az değişken olmasıdır. Dezavantajı, adım değeri üzerinde kontrol sahibi olmadığınız ve döngü gövdesi içindeki döngü indeksine erişiminiz olmadığıdır.

En iyi, adım değeri 1 basit bir artış olduğunda ve yalnızca geçerli döngü elemanına erişmeniz gerektiğinde kullanılır. Örneğin, bir dizideki veya Koleksiyondaki her öğenin üzerine, geçerli öğenin önüne veya arkasına bakmadan dönmeniz gerekirse.

Döngü başlatması yok, boolean koşulu yok ve adım değeri kapalı ve basit bir artış. Bu nedenle döngüler için normalden çok daha basit sayılırlar.

Döngü için geliştirilmiş bu yürütme sırasını izleyin:

1) döngü gövdesi

2) dizi veya koleksiyonun tamamı geçinceye kadar adım 1'den itibaren tekrarlayın

Örnek - Tam Sayı Dizisi

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

CurrentValue değişkeni, intArray dizisinde devredilen geçerli değeri tutar. Açık bir adım değeri olmadığına dikkat edin - her zaman 1 oranında bir artış olur.

Kolonun “içeri” demek olduğu düşünülebilir. Dolayısıyla, döngü bildirimi için geliştirilmiş durum şöyledir: intArray üzerinden döngü ve geçerli dizi int değerini saklayın in currentValue değişkeni.

Çıktı:

1
3
5
7
9

Örnek - Dize Array

Bir dizi dizgiyi yinelemek için for-every döngüsünü kullanabiliriz. Döngü bildirimi şöyledir: myStrings String dizisinin üzerinden döngü ve geçerli String değerini in currentString değişkenini saklayın.

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

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

Çıktı:

alpha
beta
gamma
delta

Örnek - Liste

Döngü için geliştirilmiş, bir Java.util.List üzerinde yineleme yapmak için aşağıdaki gibi de kullanılabilir:

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

Döngü bildirimi şöyledir: myList Dizeler Listesi üzerinde döngü ve geçerli Liste değerini in currentItem değişkenini saklar.

Çıktı:

alpha
beta
gamma
delta

Örnek - Ayarla

Döngü için geliştirilmiş ayrıca bir Java.util.Set üzerinde yineleme yapmak için de kullanılabilir:

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

Döngü bildirimi: mySet Strings Set üzerinden döngü ve geçerli Set değerini saklar in currentItem değişkeni. Bu bir Küme olduğundan, yinelenen Dize değerlerinin kaydedilmediğine dikkat edin.

Çıktı:

alpha
delta
beta
gamma

Kaynak: Java’daki döngüler - Nihai Kılavuz

Her bir deyim için Java, yalnızca * Yinelenebilir türündeki dizilere veya nesnelere uygulanabilir. Bu deyim örtük gerçekten bir Yineleyici tarafından desteklendiği gibi. Yineleyici programcı tarafından programlanır ve konumunu izlemek için genellikle bir tam sayı dizini veya bir düğüm kullanır (veri yapısına bağlı olarak). Kağıt üzerinde, normal bir döngü için daha yavaş, en azından diziler ve Listeler gibi "doğrusal" yapılar için daha yavaş ama daha fazla soyutlama sağlıyor.

Bu çılgınca görünüyor ama çalışıyor

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

Bu çalışıyor. Büyü