고려하세요:
List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList
for (String item : someList) {
System.out.println(item);
}
for구문을 사용하지 않고 동등한
for` 루프는 어떤 모습일까요?
for (Iterator<String> 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을 참조하세요.
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.
}
따라서 전체 요약: < br/>; [\ [nsayer]] [1] 다음은 긴 형태의 무슨일인거죠:
>. 대한 (Iterator< String>; i = 섬리스트리트레이터 (); 이스마스네스트 (); ) { >. 구체화하십시오 항목설명프로세서 = 이네스네스트 (); >. 시스템지우트리프린틀린 (item). >. } >. >. 참고로 사용해야 할 경우 >. i.레모프 (); in your 루프 또는 액세스 >. 실제 반복자가 어떤 방법으로 >. 위해 사용할 수 없습니다 (: 관용구, 이후) >. 실제 반복자가 불과하다 >. 유추.
[2] [\ [데니스 Bueno]]
>. # 39 에 의해 함축된 it& nsayer& # 39 라고 하지만, s >. # 39 에 달하는 it& 확인하면서 OP& # 39, s (.) >. 구문, someList" " 경우에는 작동합니다. 는 >. 구현하는 것도 >. it doesn& 자바드란g. 구티에레이블 # 39 없다. >. 수, 또는 일부 수집 목록 >. 제바스티우스 심지어 자신의 유형, >. 따라서 이 함께 사용할 수 있습니다. >. 구문.
[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
또 이 '포리치' 루프, jave 5 (일명 & 크로트 크로트 loop& 향상,,,) 는 avamer 사용하는 it& 3 - ['제바스티우스트레이터'] # 39 의 통사 설탕 한 것. 이에 따라 각 요소에 읽을 때 하나씩 순서대로 a '와' 포리치 사탄들 반복자가 통해 항상 있기 때문에 더 편리하고 간결하게.
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());
}
'직접' 반복자가 충족되었으며 사용해야 하는 경우가 있습니다. 예를 들어, 시도중입니다 요소를 삭제하시겠습니까 사용하는 동안 '포리치' 가 (윌?) '' 콘스해류모디피카시오네스세페시옹 됩니다.
즉, 유일한 차이점은 '에 대해 실질적인' 와 '포리치' 의 경우, 당신은 색인가능 객체에는 액세스할 수 없는 색인입니다. 예를 들어 '기본' 을 때 루프 필요합니다.
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++;
...
}
이후 갖추고 있지 않는 것이 좋습니다, 변수 범위를 '는 단순히 "에 대한 기본적인 루프 표준 및 예상 형식과 엔드입니다 览侩 荤례.
훨씬 빠르게 '는 액세스하면 컬렉션, a' 포리치 '기본' 에 비해 loop& # 39 의 어레이입니다 액세스입니다. 함께 그러나 dell. 액세스하면 어레이에는 프리미티브 및 래퍼 어레이에는 액세스만 indexe 통해 가장 빠르게 얻을 수 있습니다.
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 는 없다. 그냥 테스트 클래스 int 어레이입니다 변경하십시오 에서 다음과 같이 사용된다.
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>', '길이' 을 ', 크기 ()' 등):
[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)
이 post 는 2 일 기준으로 스택 오버플로입니다 답변 I wrote:
일부 추가 정보: , 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
다음은 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 를 지원하지 않는 어레이입니다 인덱스화를 못하며창조된 구현하십시오 이트레이블 인터페이스입니다.
[JLS] [1] 각 루프 두 가지 형식이 정의되어 있을 수 있습니다.
List< String>; 섬리스트 = new ArrayList< String> ();;; 섬리스트리아다 (Apple" ";). 섬리스트리아다 (Ball" ";). 대한 (구체화하십시오 항목: 섬리스트) { 시스템지우트리프린틀린 (item). }
// 공감대를 형성하고 있다.
대한 (Iterator< String>; 스트린기트레이터 = 섬리스트리트레이터 (); 스트린기트레이터스하스네스트 (); ) { 구체화하십시오 항목설명프로세서 = 스트린기트레이터스네스트 (); 시스템지우트리프린틀린 (item). }
문자열 [], [2] = new 문자열이어야 소미어리 [0] = " 소미어리 Apple";; [1] = " 소미어리 Ball";;
대한 (구체화하십시오 item2: 소미어리) { 시스템지우트리프린틀린 (item2); }
// 공감대를 형성하고 있다. 대한 (int i = 0; 내가 <. 소메어리드렌크스. 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
포리치 는 루프 구문은 다음과 같습니다.
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
Java " for-each"; 루프를 통해 이터레이션에 chunghwa 하면 두 가지 유형의 안내선:
t [] '-' (어레이에는 모든 유형의) java.lang.iterable< T> '-';;
이 ',' 인터페이스입니다 T> Iterable<, 하나뿐인 방법: 'Iterator< T>; 반복자가 () '. 이 때문에 ',' 유형 '객체를 작동됨 T> Collection<;;', ',' 연장시킵니다 Collection< T> 인터페이스입니다 Iterable< T>.
루프 언급한 바와 같이 포리치 개념은 위키백과에서 강조표시됩니다 다음과 같습니다.
>. 그러나 일반적으로 구문 포리치 달리 for 루프는 루프 >. 유지관리하지 명시적인 엇회전식 : 그들은 기본적으로 " 이렇게 말한다. >. 이 모든 것이 아닌, 이 x times" 못하며창조된 " set";). 이렇게 되면 >. 1 씩 오프하도록 간단해진다는 하면 오류가 발생할 수 있는 코드를 읽을 수 있습니다.
그래서 포리치 루프 (loop) 에 대한 개념을 사용하지 않으며 명시성 엇회전식 필요가 없다는 것을 의미하는 indexe 사용하여 목록에 트래버스합니다 따라서 준비되기까지 절약합니다 1 씩 오프하도록 오류:. 일반적인 개념을 설명하는 데 이 1 씩 오프하도록 오류, 알려 목록에 트래버스합니다 indexe 사용하여 루프를 불러키지 들 수 있다.
// In this loop it is assumed that the list starts with index 0
for(int i=0; i<list.length; i++){
}
하지만 예를 들어, 만약 목록이 인덱스화할 시작하여 다음 예외가 발견되지 않을 뿐만 아니라 1 이 루프 진행 과정은 요소점 인덱스 0 에서 이 오류가 호출됨 오버클로킹된 1 씩 오프하도록 오류:. 그래서 이 오류를 피하기 위해 1 씩 오프하도록 개념은 포리치 루프 사용됩니다. 너무 다른 이점이 있을 수 있지만, 이것이 내가 생각하는 가장 중요한 개념 및 사용 루프지 포리치 활용할 수 있습니다.
이전 버전 사용 '포리치' 7 '등' jave jave 루프 다음과 같이 사용할 수 있습니다.
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);
}
다음은 가장 최신의 방법을 사용하여 '포리치' 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);
자세한 정보는 이 링크를) 는 다음과 같은 뜻이 있다.
자바 가상 머신 (jvm) 에 8, 그들은 포리치 소개했다. 이 목록을 사용하여 매핑하며 루프 수 있습니다.
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);
});
포리치 를 대체할 것을 방지하기 위해 너회의 " each":
List<String> someList = new ArrayList<String>();
변형 1 (일반):
someList.stream().forEach(listItem -> {
System.out.println(listItem);
});
변형 2 (평행광 실행 (빠른):
someList.parallelStream().forEach(listItem -> {
System.out.println(listItem);
});
이 아름다운 코드에 자도으로 제거하여 모든 기본 루프을 단순화됩니다. 이를 통해 깨끗한 여바바 데이터베이스에구성원을 코드, 자리맞춤 같습니다.
void cancelAll(Collection<TimerTask> list) {
for (Iterator<TimerTask> i = list.iterator(); i.hasNext();)
i.next().cancel();
}
void cancelAll(Collection<TimerTask> list) {
for (TimerTask t : list)
t.cancel();
}
다음 줄을 따라 각 티머타스크 읽어옵니다 ", t in list.".
for (TimerTask t : list)
오류의 가능성이 적은 경우에 각. # 39, t 는 반복자가 또는 초기화중 초기화중 너회가 don& 걱정할 필요가 없다 '는 루프 엇회전식 종료 및 it (있는 곳에는 유효범위 오류에 대해).
이에 앞서 8 jave 사용해야 할 사항은 다음과 같습니다.
Iterator<String> 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