Java 'for Each' 루프는 어떻게 작동합니까?

Question

고려하다:

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

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

동등한 것은 무엇입니까? for 루프는 사용하지 않은 것처럼 보입니다. 각각 통사론?

Answer 1

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

꼭 사용해야 한다면 참고하세요 i.remove(); 루프에서 또는 어떤 방식으로든 실제 반복기에 액세스하면 for ( : ) 관용구, 실제 반복자는 단지 추론되기 때문입니다.

Denis Bueno가 언급한 것처럼 이 코드는 다음을 구현하는 모든 개체에 대해 작동합니다. Iterable 상호 작용.

또한, 오른쪽에 있는 경우 for (:) 관용어는 array 보다는 Iterable 객체의 내부 코드는 int 인덱스 카운터를 사용하고 다음을 확인합니다. array.length 대신에.참조 자바 언어 사양.

Answer 2

구조 각각 배열에도 유효합니다.예를 들어

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

그래서 전체적인 요약은 다음과 같습니다.
[말하는 사람] 다음은 현재 일어나고 있는 일의 더 긴 형식입니다.

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

i.remove ()를 사용해야하는 경우;루프에서 또는 실제 반복자에 어떤 식 으로든 액세스하면 for (:) 관용구, 실제 반복자는 단지 추론되기 때문에.

[데니스 부에노]

NSAYER의 답변에 의해 암시되지만, OP의 (..) 구문은 "SOMELIST"가 java.lang. java.util.따라서이 구문과 함께 자신의 유형조차 사용할 수 있습니다.

Answer 3

그만큼 foreach 고리, 추가됨 자바 5 ("향상된 for 루프"라고도 함)은 java.util.Iterator--동일한 구문 설탕입니다.따라서 각 요소를 하나씩 순서대로 읽을 때 foreach 더 편리하고 간결하므로 항상 반복자보다 선택해야 합니다.

각각

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

반복자

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

사용해야 하는 상황이 있습니다. Iterator 곧장.예를 들어, foreach (할 것인가?) 결과가 나올 수 있다 ConcurrentModificationException.

foreach 대 for:기본적인 차이점

실제적인 유일한 차이점은 for 그리고 foreach 즉, 색인 생성 가능한 개체의 경우 색인에 액세스할 수 없습니다.기본일 때의 예 for 루프가 필요합니다:

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

다음을 사용하여 별도의 인덱스 int 변수를 수동으로 생성할 수 있지만 foreach,

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

권장되지 않습니다. 왜냐하면 가변 범위 이상적이지 않으며 기본 for 루프는 단순히 이 사용 사례에 대한 표준이자 예상되는 형식입니다.

foreach 대 for:성능

컬렉션에 접근할 때, foreach ~이다 훨씬 더 빠르게 기본보다 for 루프의 배열 액세스.그러나 배열에 액세스할 때(적어도 기본 배열 및 래퍼 배열의 경우) 인덱스를 통한 액세스가 훨씬 더 빠릅니다.

기본 int 배열에 대한 반복자와 인덱스 액세스 간의 차이 타이밍

인덱스는 23-40 액세스할 때 반복자보다 퍼센트 더 빠릅니다. int 또는 Integer 배열.다음은 이 게시물 하단에 있는 테스트 클래스의 출력입니다. 이 출력은 100개 요소로 구성된 원시 정수 배열(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)

나는 또한 이것을 위해 달렸다 Integer 배열과 인덱스가 여전히 확실한 승자이지만 속도는 18~25%만 더 빠릅니다.

컬렉션의 경우 반복자가 인덱스보다 빠릅니다.

에 대한 List ~의 Integers, 그러나 반복자가 확실한 승자입니다.테스트 클래스의 int-array를 다음과 같이 변경하세요.

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

그리고 테스트 기능(int[] 에게 List<Integer>, length 에게 size(), 등.):

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

한 테스트에서는 거의 동일하지만 컬렉션을 사용하면 반복자가 승리합니다.

*이 게시물은 제가 Stack Overflow에 쓴 두 가지 답변을 바탕으로 작성되었습니다.

• Java의 for-each 루프 사용 및 구문

• 반복하려면 Iterator나 forloop를 사용해야 합니까?

추가 정보: for-each 루프와 반복자 중 어느 것이 더 효율적인가요?

전체 테스트 클래스

나는 책을 읽은 후 두 가지 일을 하는 데 걸리는 시간 비교 수업을 만들었습니다. 이 질문 스택 오버플로:

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

다음은 Java 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]
}

foreach 구문을 사용하면 이 공통 패턴을 보다 자연스럽고 구문적으로 덜 시끄러운 방식으로 작성할 수 있습니다.

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

또한 이 구문은 배열 인덱싱을 지원하지 않지만 Java Iterable 인터페이스를 구현하는 목록 또는 세트와 같은 객체에 유효합니다.

Answer 5

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

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

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

Answer 6

Java 8 기능에서는 다음을 사용할 수 있습니다.

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

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

산출

First
Second
Third

Answer 7

nsayer의 답변에서 암시되지만 "someList"가 다음과 같은 경우 OP의 for(..) 구문이 작동한다는 점은 주목할 가치가 있습니다. 아무것 이는 java.lang.Iterable을 구현합니다. 목록이거나 java.util의 일부 컬렉션일 필요는 없습니다.따라서 사용자 고유의 유형도 이 구문과 함께 사용할 수 있습니다.

Answer 8

foreach 루프 구문은 다음과 같습니다.

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

경고:foreach 루프를 사용하여 배열 요소에 액세스할 수 있지만 초기화할 수는 없습니다.원본을 사용하세요 for 그것을 위해 루프.

경고:배열 유형을 다른 객체와 일치시켜야 합니다.

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

요소를 편집하려면 원본을 사용하세요. for 다음과 같이 반복하십시오 :

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

Answer 9

정의된 대로 JLS for-each 루프는 두 가지 형식을 가질 수 있습니다.

1. 표현식 유형이 하위 유형인 경우 Iterable 그러면 번역은 다음과 같습니다:

   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. 표현식에 반드시 배열 유형이 있는 경우 T[] 그 다음에:

   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에서는 일반적으로 더 나은 성능을 발휘하는 스트림을 도입했습니다.우리는 그것들을 다음과 같이 사용할 수 있습니다:

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

Answer 10

Java의 "for-each" 루프 구성은 두 가지 유형의 객체에 대한 반복을 허용합니다.

• T[] (모든 유형의 배열)
• java.lang.Iterable<T>

그만큼 Iterable<T> 인터페이스에는 한 가지 방법만 있습니다: Iterator<T> iterator().이것은 유형의 객체에서 작동합니다. Collection<T> 왜냐하면 Collection<T> 인터페이스 확장 Iterable<T>.

Answer 11

Wikipedia에서 언급된 foreach 루프의 개념은 아래에 강조되어 있습니다.

그러나 루프 구조의 경우 다른 것과는 달리, Foreach 루프는 일반적으로 유지됩니다. 명시적인 카운터 없음:그들은 본질적으로 "이 X 시간을하는 것"보다는 "이 세트의 모든 것에 이것을 수행하십시오"라고 말합니다.이것은 잠재력을 피합니다 일대일 오류 코드를 더 쉽게 읽을 수 있게 해줍니다.

따라서 foreach 루프의 개념은 루프가 명시적인 카운터를 사용하지 않는다는 점을 설명합니다. 즉, 목록을 탐색하기 위해 인덱스를 사용할 필요가 없으므로 사용자가 하나씩 오류로부터 벗어날 수 있다는 의미입니다.이 off-by-one 오류의 일반적인 개념을 설명하기 위해 인덱스를 사용하여 목록을 순회하는 루프의 예를 들어 보겠습니다.

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

}

그러나 목록이 인덱스 1로 시작하면 이 루프는 인덱스 0에서 요소를 찾을 수 없기 때문에 예외를 발생시킬 것이며 이 오류를 off-by-one 오류라고 합니다.따라서 이러한 off-by-one 오류를 방지하기 위해 foreach 루프 개념이 사용됩니다.다른 장점도 있을 수 있지만 이것이 foreach 루프 사용의 주요 개념이자 장점이라고 생각합니다.

Answer 12

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

Answer 13

다음은 동등한 표현입니다.

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

Answer 14

또한 원래 질문에서 "foreach" 메서드를 사용하면 반복 중에 목록에서 항목을 제거할 수 없는 등 몇 가지 제한 사항이 있습니다.

새로운 for 루프는 읽기가 더 쉽고 별도의 반복자가 필요하지 않지만 실제로는 읽기 전용 반복 단계에서만 사용할 수 있습니다.

Answer 15

다음을 포함한 이전 Java 버전 사용 Java 7 당신이 사용할 수있는 foreach 다음과 같이 반복하십시오.

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

다음은 최신 사용 방법입니다. foreach 루프 인 Java 8

(목록을 반복합니다. forEach + 람다 식 또는 메서드 참조)

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

Answer 16

"각각"을 피하기 위한 forEach의 대안:

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

변형 1(일반):

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

변형 2(병렬 실행(더 빠름)):

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

Answer 17

모든 기본 반복 혼란을 제거하여 코드에 아름다움을 더합니다.아래에 설명된 대로 코드를 깔끔하게 보여줍니다.

정상 for 고리:

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

for-each 사용:

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

각각 구현하는 컬렉션에 대한 구성입니다. 반복자.컬렉션에서 구현해야 한다는 점을 기억하세요. 반복자;그렇지 않으면 for-each와 함께 사용할 수 없습니다.

다음 줄은 "목록의 각 TimerTask t에 대해."

for (TimerTask t : list)

for-each의 경우 오류가 발생할 가능성이 적습니다.반복자를 초기화하거나 루프 카운터를 초기화하고 종료하는 것에 대해 걱정할 필요가 없습니다(오류 범위가 있는 경우).

Answer 18

Java 8에서는 forEach를 도입했습니다.List를 사용하면 지도를 반복할 수 있습니다.

for Each를 사용하여 목록 반복

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

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

또는

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

각각을 사용하여 지도 반복

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

또는

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

Answer 19

다음과 같이 보일 것입니다.매우 잔인하다.

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

에 좋은 글이 있습니다 각각 에서 썬 문서.

Answer 20

Java 8 이전에는 다음을 사용해야 합니다.

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

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

그러나 Java 8에 Streams가 도입되면서 훨씬 적은 구문으로 동일한 작업을 수행할 수 있습니다.예를 들어, 귀하의 경우 someList 넌 할 수있어:

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

스트림에 대해 자세히 알아볼 수 있습니다. 여기.

Answer 21

많은 좋은 답변이 말했듯이 객체는 Iterable interface 만약 그것이 사용하고 싶다면 for-each 고리.

간단한 예를 게시하고 다른 방식으로 설명하려고 노력하겠습니다. for-each 루프가 작동합니다.

그만큼 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);
        }
    }
}

그렇다면, 우리가 사용한다면 javap 이 클래스를 디컴파일하기 위해 다음 바이트코드 샘플을 얻습니다.

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;

샘플의 마지막 줄에서 볼 수 있듯이 컴파일러는 자동으로 for-each 사용에 대한 키워드 Iterator 컴파일 타임에.이는 객체가 구현하지 않는 이유를 설명할 수 있습니다. Iterable interface, 던질 것이다 Exception 그것을 사용하려고 할 때 for-each 고리.

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

그만큼 각 루프에 대한 Java (일명 향상된 for 루프)는 for 루프의 단순화된 버전입니다.장점은 작성해야 할 코드가 적고 관리해야 할 변수가 적다는 것입니다.단점은 단계 값을 제어할 수 없고 루프 본문 내부의 루프 인덱스에 액세스할 수 없다는 것입니다.

이는 단계 값이 1의 단순한 증분일 때와 현재 루프 요소에만 액세스해야 할 때 가장 잘 사용됩니다.예를 들어 현재 요소 앞이나 뒤를 엿보지 않고 배열이나 컬렉션의 모든 요소를 ​​반복해야 하는 경우입니다.

루프 초기화도 없고 부울 조건도 없으며 단계 값은 암시적이며 단순 증분입니다.이것이 바로 일반적인 for 루프보다 훨씬 간단하다고 간주되는 이유입니다.

향상된 for 루프는 다음 실행 순서를 따릅니다.

1) 루프 본체

2) 전체 배열이나 컬렉션을 탐색할 때까지 1단계부터 반복합니다.

예 – 정수 배열

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

currentValue 변수는 intArray 배열에서 반복되는 현재 값을 보유합니다.명시적인 단계 값은 없습니다. 항상 1씩 증가합니다.

콜론은 "in"을 의미한다고 생각될 수 있습니다.따라서 향상된 for 루프 선언에는 다음과 같은 내용이 나와 있습니다.intArray를 반복하고 현재 배열 int 값을 저장합니다. ~에 currentValue 변수.

산출:

1
3
5
7
9

예 – 문자열 배열

for-each 루프를 사용하여 문자열 배열을 반복할 수 있습니다.루프 선언에는 다음과 같이 명시되어 있습니다.myStrings String 배열을 반복하고 현재 String 값을 저장합니다. ~에 currentString 변수.

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

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

산출:

alpha
beta
gamma
delta

예 - 목록

향상된 for 루프를 사용하여 다음과 같이 java.util.List를 반복할 수도 있습니다.

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

루프 선언에는 다음과 같이 명시되어 있습니다.myList 문자열 목록을 반복하고 현재 목록 값을 저장합니다. ~에 currentItem 변수.

산출:

alpha
beta
gamma
delta

예 – 설정

향상된 for 루프를 사용하여 다음과 같이 java.util.Set을 반복할 수도 있습니다.

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

루프 선언에는 다음과 같이 명시되어 있습니다.mySet 문자열 집합을 반복하고 현재 설정 값을 저장합니다. ~에 currentItem 변수.이는 Set이므로 중복된 String 값은 저장되지 않습니다.

산출:

alpha
delta
beta
gamma

원천: Java의 루프 - 최종 가이드

Answer 24

Java for-each 관용구는 유형의 배열 또는 객체에만 적용될 수 있습니다. *반복 가능.이 관용어는 절대적인 Iterator가 실제로 지원하기 때문입니다.Iterator는 프로그래머가 프로그래밍하며 위치를 추적하기 위해 종종 정수 인덱스나 노드(데이터 구조에 따라)를 사용합니다.서류상으로는 배열 및 목록과 같은 "선형" 구조의 경우 일반 for-loop보다 속도가 느리지만 더 뛰어난 추상화를 제공합니다.

Answer 25

이거 이상해 보이는데 효과가 있네

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

이것은 작동합니다. 마법

Answer 26

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

Items 테이블의 모든 객체를 반복합니다.