Java 'for each' 루프는 어떻게 작동하나요?

고려하세요:

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

for구문을 사용하지 않고 동등한for` 루프는 어떤 모습일까요?

Jay R.
편집된 질문23일 2월 2018 в 1:21
프로그래밍
java foreach syntactic-sugar
17일 9월 2008 в 4:44
13 파운드
질문에 대한 의견 (1)
해결책
for (Iterator i = someIterable.iterator(); i.hasNext();) {
    String item = i.next();
    System.out.println(item);
}

루프에서 i.remove();를 사용하거나 어떤 방식으로든 실제 이터레이터에 액세스해야 하는 경우, 실제 이터레이터는 단지 추론될 뿐이므로 for ( : ) 관용구를 사용할 수 없다는 점에 유의하세요.

데니스 부에노가 언급했듯이, 이 코드는 Iterable 인터페이스를 구현하는 모든 객체에서 작동합니다.

또한 for (:) 관용구의 오른쪽이 Iterable 객체가 아닌 array인 경우 내부 코드에서는 int 인덱스 카운터를 사용하고 대신 array.length를 확인합니다. Java 언어 사양]2을 참조하세요.

해설 (4)
    • 역시 사용할 수 있는 각 chunghwa 배열입니다. 예:
String[] fruits = new String[] { "Orange", "Apple", "Pear", "Strawberry" };

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

이는 본질적으로 같은

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

따라서 전체 요약: &lt br/>; [\ [nsayer]] [1] 다음은 긴 형태의 무슨일인거죠:

&gt. 대한 (Iterator&lt String>; i = 섬리스트리트레이터 (); 이스마스네스트 (); ) { &gt. 구체화하십시오 항목설명프로세서 = 이네스네스트 (); &gt. 시스템지우트리프린틀린 (item). &gt. } &gt. &gt. 참고로 사용해야 할 경우 &gt. i.레모프 (); in your 루프 또는 액세스 &gt. 실제 반복자가 어떤 방법으로 &gt. 위해 사용할 수 없습니다 (: 관용구, 이후) &gt. 실제 반복자가 불과하다 &gt. 유추.

[2] [\ [데니스 Bueno]]

&gt. # 39 에 의해 함축된 it& nsayer& # 39 라고 하지만, s &gt. # 39 에 달하는 it& 확인하면서 OP& # 39, s (.) &gt. 구문, someList&quot &quot 경우에는 작동합니다. 는 &gt. 구현하는 것도 &gt. it doesn& 자바드란g. 구티에레이블 # 39 없다. &gt. 수, 또는 일부 수집 목록 &gt. 제바스티우스 심지어 자신의 유형, &gt. 따라서 이 함께 사용할 수 있습니다. &gt. 구문.

[1]: # 85206 https://stackoverflow.com/questions/85190/how-does-the-java-for-each-loop-work/85206 [2]: # 85242 https://stackoverflow.com/questions/85190/how-does-the-java-for-each-loop-work/85242

해설 (0)

또 이 '포리치' 루프, jave 5 (일명 &amp 크로트 크로트 loop&amp 향상,,,) 는 avamer 사용하는 it& 3 - ['제바스티우스트레이터'] # 39 의 통사 설탕 한 것. 이에 따라 각 요소에 읽을 때 하나씩 순서대로 a '와' 포리치 사탄들 반복자가 통해 항상 있기 때문에 더 편리하고 간결하게.

포리치

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

반복자가

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

'직접' 반복자가 충족되었으며 사용해야 하는 경우가 있습니다. 예를 들어, 시도중입니다 요소를 삭제하시겠습니까 사용하는 동안 '포리치' 가 (윌?) '' 콘스해류모디피카시오네스세페시옹 됩니다.

'포리치' 는 ':' vs. 기본 변경분

즉, 유일한 차이점은 '에 대해 실질적인' 와 '포리치' 의 경우, 당신은 색인가능 객체에는 액세스할 수 없는 색인입니다. 예를 들어 '기본' 을 때 루프 필요합니다.

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

직접 만들 수도 있지만, 별도의 인덱스화할 변수 int 포리치 '와'

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

이후 갖추고 있지 않는 것이 좋습니다, 변수 범위를 '는 단순히 "에 대한 기본적인 루프 표준 및 예상 형식과 엔드입니다 览侩 荤례.

'포리치' 는 ':' vs. Performance&lt /H2>;

훨씬 빠르게 '는 액세스하면 컬렉션, a' 포리치 '기본' 에 비해 loop& # 39 의 어레이입니다 액세스입니다. 함께 그러나 dell. 액세스하면 어레이에는 프리미티브 및 래퍼 어레이에는 액세스만 indexe 통해 가장 빠르게 얻을 수 있습니다.

반복자가 및 인덱스를 위한 기본적인 차이점은 int 어레이에는 액세스 타이밍

Int '또는' 정수 '보다' iterator) 가 인덱스가 23-40 액세스하면 배열입니다. 다음은 이 게시물 하단에 있는 자금을 출력입니다 테스트 클래스가 있는 숫자는 100 요소점 프리미티브 int 어레이입니다 (a 는 b 를 반복자가 인덱스화할):

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

난 또 이 경우, 인덱스 '정수' 어레이입니다 실행했음 뿐 여전히 분명한 승리자가 되었다는 25 ~ 18 퍼센트 를 가속화합니다.

Iterator 의 컬렉션, 기차보다 인덱스화합니다

그러나 '정수' 의 '목록' 에 대한 선택해제합니다 iterator 는 없다. 그냥 테스트 클래스 int 어레이입니다 변경하십시오 에서 다음과 같이 사용된다.

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

저회가 필요한 변화를 테스트 기능을 ('int []' 을 'list&lt, integer&gt', '길이' 을 ', 크기 ()' 등):

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

39 한 테스트 they&, re 아찔했어 avamer 갖추고 있지만, 컬렉션, 반복자가 경기다.

일부 추가 정보: , https://stackoverflow.com/questions/2113216/which-is-more-efficient-a-for-each-loop-or-an-iterator

전체 테스트 클래스

이 질문 를 읽은 후 내가 만든 이 걸리는 시간은 두 가지 비교 할 수 있습니다 클래스용 스택할 오버플로입니다:

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

}

[6]: # 22110517 https://stackoverflow.com/questions/22110482/uses-and-syntax-for-for-each-loop-in-java/22110517

Peter Mortensen
편집된 답변16일 3월 2018 в 1:35
해설 (7)

다음은 solaris. 지식이 없는 답을 jave iterator. 정확히까지 교육을 위한 유용한 것은 적다.

프로그래밍 코드를 작성할 때 우리는 종종 보이는 다음과 같습니다.

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

이 구문은 일반적인 패턴을 포리치 를 사용하면 보다 자연스럽고 구조상 소음이 적은 쓸 수 없다.

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

또한 이 구문은 유효함 객체에는 열거합니다 또는 세트 등 아니라 어떤 Java 를 지원하지 않는 어레이입니다 인덱스화를 못하며창조된 구현하십시오 이트레이블 인터페이스입니다.

Peter Mortensen
편집된 답변16일 3월 2018 в 1:12
해설 (0)

Java의 for-each 루프는 기본 반복자 메커니즘을 사용합니다. 따라서 다음과 동일합니다:

Iterator iterator = someList.iterator();

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

자바 가상 머신 (jvm) 에 8 이 기능을 사용할 수 있습니다.

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

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

출력입니다

First
Second
Third
해설 (1)

39 에 의해 함축된 it& nsayer& # 39 라고 하지만, s, s # 39 에 달하는 it& 확인하면서 OP& # 39 (.) 구문, someList&quot &quot 경우에는 작동합니다. it doesn& # 39 는 구현하는 anything 자바드란g. 구티에레이블 바뀌엇어요 제바스티우스 수집, 또는 일부 수 없다. 심지어 자신의 유형, 따라서 이 문법을 사용할 수 있습니다.

해설 (2)

[JLS] [1] 각 루프 두 가지 형식이 정의되어 있을 수 있습니다.

  1. '다음' 의 경우 유형의 표현은 하위형식 이트레이블 번역은 다음과 같습니다.

List&lt String>; 섬리스트 = new ArrayList&lt String&gt ();;; 섬리스트리아다 (Apple&quot ";). 섬리스트리아다 (Ball&quot ";). 대한 (구체화하십시오 항목: 섬리스트) { 시스템지우트리프린틀린 (item). }

// 공감대를 형성하고 있다.

대한 (Iterator&lt String>; 스트린기트레이터 = 섬리스트리트레이터 (); 스트린기트레이터스하스네스트 (); ) { 구체화하십시오 항목설명프로세서 = 스트린기트레이터스네스트 (); 시스템지우트리프린틀린 (item). }

  1. [] '즉' T 는 표현식에서는 경우 반드시 어레이에서는 유형

문자열 [], [2] = new 문자열이어야 소미어리 [0] = &quot 소미어리 Apple";; [1] = &quot 소미어리 Ball";;

대한 (구체화하십시오 item2: 소미어리) { 시스템지우트리프린틀린 (item2); }

// 공감대를 형성하고 있다. 대한 (int i = 0; 내가 &lt. 소메어리드렌크스. i++) { 구체화하십시오 item2 = 소미어리 [i]; 시스템지우트리프린틀린 (item2); }

일반적으로 스트리밍합니다 jave 8 은 수행하는 것입니다. 솔리드로 사용할 수 있습니다.

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

[1]: http://docs.oracle.com/javase/specs/jls/se8/html/jls-14.html # jls-14.14.2

해설 (1)

포리치 는 루프 구문은 다음과 같습니다.

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

예:

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

출력:

Java
Coffe
Is
Cool

경고: 액세스하려면 어레이입니다 요소 중 포리치 루프 저들이요 초기화하지 수는 없습니다 '오리지널' 을 사용하여 루프 iqn.

경고: 다른 유형의 어레이에는 객체에는 일치시킵니다 합니다.

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

'오리지널' 을 사용할 경우, 다음과 같은 요소를 편집하려는 루프

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

이제 우리가 덤프하지 s 콘솔, 우리.

hello
2 is cool
hello
hello
Peter Mortensen
편집된 답변16일 3월 2018 в 1:16
해설 (0)

Java &quot for-each"; 루프를 통해 이터레이션에 chunghwa 하면 두 가지 유형의 안내선:

t [] '-' (어레이에는 모든 유형의) java.lang.iterable&lt T&gt '-';;

이 ',' 인터페이스입니다 T&gt Iterable&lt, 하나뿐인 방법: 'Iterator&lt T>; 반복자가 () '. 이 때문에 ',' 유형 '객체를 작동됨 T&gt Collection<;;', ',' 연장시킵니다 Collection&lt T&gt 인터페이스입니다 Iterable&lt T&gt.

해설 (0)

루프 언급한 바와 같이 포리치 개념은 위키백과에서 강조표시됩니다 다음과 같습니다.

&gt. 그러나 일반적으로 구문 포리치 달리 for 루프는 루프 &gt. 유지관리하지 명시적인 엇회전식 : 그들은 기본적으로 &quot 이렇게 말한다. &gt. 이 모든 것이 아닌, 이 x times&quot 못하며창조된 &quot set";). 이렇게 되면 &gt. 1 씩 오프하도록 간단해진다는 하면 오류가 발생할 수 있는 코드를 읽을 수 있습니다.

그래서 포리치 루프 (loop) 에 대한 개념을 사용하지 않으며 명시성 엇회전식 필요가 없다는 것을 의미하는 indexe 사용하여 목록에 트래버스합니다 따라서 준비되기까지 절약합니다 1 씩 오프하도록 오류:. 일반적인 개념을 설명하는 데 이 1 씩 오프하도록 오류, 알려 목록에 트래버스합니다 indexe 사용하여 루프를 불러키지 들 수 있다.


// In this loop it is assumed that the list starts with index 0
for(int i=0; i
Peter Mortensen
편집된 답변16일 3월 2018 в 1:14
해설 (0)
for (Iterator itr = someList.iterator(); itr.hasNext(); ) {
   String item = itr.next();
   System.out.println(item);
}
해설 (0)

이전 버전 사용 '포리치' 7 '등' jave jave 루프 다음과 같이 사용할 수 있습니다.

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

다음은 가장 최신의 방법을 사용하여 '포리치' 8 '에서' jave 루프

(loop) '+' 포리치 람다 표현식 또는 방법이 있는 목록을 참조)

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

자세한 정보는 이 링크를) 는 다음과 같은 뜻이 있다.

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

해설 (0)

자바 가상 머신 (jvm) 에 8, 그들은 포리치 소개했다. 이 목록을 사용하여 매핑하며 루프 수 있습니다.

  • 루프를 사용하는 바뀌엇어요 각 *
List someList = new ArrayList();
someList.add("A");
someList.add("B");
someList.add("C");

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

또는

someList.forEach(listItem-> {
     System.out.println(listItem); 
});
    • Map 을 사용하여 각 반복
Map 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));

또는

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

다음은 이에 상응하는 표현입니다.

for(Iterator sit = someList.iterator(); sit.hasNext(); ) {
    System.out.println(sit.next());
}
해설 (0)

또한 name. domain. &quot foreach"; 원래 질문은 방법을 몇 가지 제한이 없는 동안, 수 없는 등의 항목을 지우시겠습니까 목록에서 이터레이션은.

제거하고 새로운 for 루프는 는 쉽게 읽을 수 있지만, 정말 필요한 경우에만 사용할 수 있는 별도의 반복자가 읽기 전용 이터레이션에 패스.

해설 (1)

포리치 를 대체할 것을 방지하기 위해 너회의 &quot each":

List someList = new ArrayList();

변형 1 (일반):

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

변형 2 (평행광 실행 (빠른):

someList.parallelStream().forEach(listItem -> {
    System.out.println(listItem);
});
Peter Mortensen
편집된 답변16일 3월 2018 в 1:38
해설 (2)

이 아름다운 코드에 자도으로 제거하여 모든 기본 루프을 단순화됩니다. 이를 통해 깨끗한 여바바 데이터베이스에구성원을 코드, 자리맞춤 같습니다.

  • Loop:* '정상' 에 대해
void cancelAll(Collection list) {
    for (Iterator i = list.iterator(); i.hasNext();)
         i.next().cancel();
}
  • For-each:* 사용하여
void cancelAll(Collection list) {
    for (TimerTask t : list)
        t.cancel();
}
        • 은 각 chunghwa 취합은 통해 구현하는 반복자가. , 반복자가 구현하십시오 너회의 취합은 것을 기억해야 한다. 그렇지 않으면, t # 39 이 기능을 사용하여 can& 각.

다음 줄을 따라 각 티머타스크 읽어옵니다 &quot, t in list.&quot.

for (TimerTask t : list)

오류의 가능성이 적은 경우에 각. # 39, t 는 반복자가 또는 초기화중 초기화중 너회가 don& 걱정할 필요가 없다 '는 루프 엇회전식 종료 및 it (있는 곳에는 유효범위 오류에 대해).

해설 (0)

이에 앞서 8 jave 사용해야 할 사항은 다음과 같습니다.

Iterator iterator = someList.iterator();

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

그러나 스트리밍합니다 8 의 출시와 함께 할 수 있는 자바 가상 머신 (jvm) 에 훨씬 적은 구문을 같은 것이 있다. 예를 들어, '섬리스트 단축시킵니다' 할 수 있습니다.

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

[Here] 스트리밍합니다 대해 더 많이 찾을 수 있습니다.

[here): https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html

Peter Mortensen
편집된 답변16일 3월 2018 в 1:40
해설 (0)

모습이 될 것이라고 주장했다. 매우 크루프티.

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

작성자 좁히어 좋은 인프라일까요 대한 각 의 쨍쨍이고 문서용으로.

해설 (0)