検討：
List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList
for (String item : someList) {
System.out.println(item);
}
for each構文を使用しないと、同等のforループはどのようになりますか?
Jay R.
質問する
2785260 次
29 に答える
1262
for (Iterator<String> i = someIterable.iterator(); i.hasNext();) {
String item = i.next();
System.out.println(item);
}
ループで使用する必要がある場合、または何らかの方法で実際の反復子にアクセスする必要がある場合、実際の反復子は単に推測されるだけなので、イディオムをi.remove();使用できないことに注意してください。for ( : )
Denis Bueno が指摘したように、このコードはIterableinterfaceを実装するすべてのオブジェクトで機能します。
for (:)また、イディオムの右側がオブジェクトでarrayはなく、内部コードであるIterable場合、内部コードは int インデックス カウンターを使用し、代わりにチェックしarray.lengthます。Java 言語仕様を参照してください。
于 2008-09-17T16:46:28.283 に答える
539
eachの構造は、配列にも有効です。例えば
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.
}
したがって、全体的な要約:
[nsayer]以下は、起こっていることのより長い形式です:
for(Iterator<String> i = someList.iterator(); i.hasNext(); ) { String item = i.next(); System.out.println(item); }i.remove(); を使用する必要がある場合は注意してください。ループ内で、または何らかの方法で実際の反復子にアクセスする場合、実際の反復子は単に推論されるため、for( : ) イディオムは使用できません。
それはnsayerの答えに暗示されていますが、「someList」がjava.lang.Iterableを実装するものである場合、OPのfor(..)構文が機能することに注意してください-リストまたはコレクションからのコレクションである必要はありませんjava.util. したがって、独自の型であっても、この構文で使用できます。
于 2008-09-17T17:06:39.157 に答える
180
Java 5で追加されたfor -each ループ(「拡張 for ループ」とも呼ばれます) は、同じことに対して --it のシンタックス シュガーを使用することと同等です。したがって、各要素を 1 つずつ順番に読み取るときは、イテレータよりも for-each の方が便利で簡潔であるため、常に選択する必要があります。java.util.Iterator
For-each
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。たとえば、for-each を使用しているときに要素を削除しようとすると (そうなりますか?) ConcurrentModificationException、.
for-each と for-loop: 基本的な違い
for-loop と for-each の唯一の実質的な違いは、インデックス可能なオブジェクトの場合、インデックスにアクセスできないことです。基本的な for ループが必要な場合の例:
for (int i = 0; i < array.length; i++) {
if(i < 5) {
// Do something special
} else {
// Do other stuff
}
}
for-each を使用して個別のインデックス int 変数を手動で作成することもできますが、
int idx = -1;
for (int i : intArray) {
idx++;
...
}
...可変スコープは理想的ではなく、基本的なforループは単にこのユースケースの標準で予想される形式であるため、お勧めしません。
for-each vs. for-loop: パフォーマンス
コレクションにアクセスする場合、for-each は基本的なループの配列アクセスよりも大幅に高速です。forただし、配列にアクセスする場合 (少なくともプリミティブ配列とラッパー配列を使用する場合)、インデックスを介したアクセスの方が劇的に高速です。
プリミティブ int 配列の反復子アクセスとインデックス アクセスのタイミングの違い
または配列にアクセスする場合、インデックスは反復子よりも 23 ～ 40 % 高速です。以下は、この投稿の最後にあるテスト クラスからの出力で、100 要素のプリミティブ int 配列 (A は反復子、B はインデックス) の数値を合計します。intInteger
[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 パーセントの高速化にとどまっています。
コレクションの場合、反復子はインデックスよりも高速です
ただし、Listof のIntegers場合、反復子が明らかに勝者です。test-class の 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[]to List<Integer>、lengthtosize()など):
[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 に書いた 2 つの回答に基づいています。
追加情報: for-each ループと反復子のどちらがより効率的ですか?
完全なテストクラス
スタックオーバーフローでこの質問を読んだ後、このcompare-the-time-it-takes-to-do-any-two-thingsクラスを作成しました:
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
}
于 2014-03-01T12:47:20.413 に答える
134
これは、Java Iterators の知識を前提としない回答です。精度は劣りますが、教育には役立ちます。
プログラミング中に、次のようなコードを書くことがよくあります。
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 インターフェイスを実装している Lists や Sets などのオブジェクトに対して有効です。
于 2011-10-31T16:35:57.580 に答える
44
Java の for-each ループは、基礎となる反復子メカニズムを使用します。したがって、次と同じです。
Iterator<String> iterator = someList.iterator();
while (iterator.hasNext()) {
String item = iterator.next();
System.out.println(item);
}
于 2008-09-17T16:46:53.913 に答える
41
JLSで定義されているように、for-each ループには次の 2 つの形式があります。
Expression の型が のサブタイプである
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); }Expression が必ず配列型を持つ場合
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);
于 2015-10-20T09:12:52.210 に答える
26
それはnsayerの答えに暗示されていますが、「someList」がjava.lang.Iterableを実装するものである場合、OPのfor(..)構文が機能することに注意してください-リストまたはコレクションからのコレクションである必要はありませんjava.util. したがって、独自の型であっても、この構文で使用できます。
于 2008-09-17T16:50:02.847 に答える
24
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
于 2013-11-07T05:35:25.547 に答える
23
Java 8 機能では、これを使用できます。
List<String> messages = Arrays.asList("First", "Second", "Third");
void forTest(){
messages.forEach(System.out::println);
}
出力
First
Second
Third
于 2014-04-19T15:22:03.023 に答える
22
Java の「for-each」ループ構成では、次の 2 種類のオブジェクトを反復処理できます。
T[](任意のタイプの配列)java.lang.Iterable<T>
このIterable<T>インターフェイスには、メソッドが 1 つしかありません: Iterator<T> iterator(). インターフェイスが extendsでCollection<T>あるため、これは のオブジェクトで機能します。Collection<T>Iterable<T>
于 2008-09-17T18:04:18.410 に答える
18
ウィキペディアで言及されている foreach ループの概念を以下に強調します。
ただし、他の for ループ構成とは異なり、 foreach ループは通常、明示的なカウンターを保持しません。基本的に、「これを x 回実行する」ではなく、「このセット内のすべてに対してこれを実行する」と言います。これにより、off-by-one エラーの可能性が回避され、コードが読みやすくなります。
したがって、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 に要素が見つからないため、このループは例外をスローし、このエラーはオフバイワン エラーと呼ばれます。したがって、このオフバイワン エラーを回避するために、foreach ループの概念が使用されます。他にも利点があるかもしれませんが、これが foreach ループを使用する主な概念であり、利点であると私は考えています。
于 2012-10-04T07:47:43.353 に答える
13
for (Iterator<String> itr = someList.iterator(); itr.hasNext(); ) {
String item = itr.next();
System.out.println(item);
}
于 2008-09-17T16:49:03.783 に答える
13
同等の表現を次に示します。
for(Iterator<String> sit = someList.iterator(); sit.hasNext(); ) {
System.out.println(sit.next());
}
于 2008-09-17T16:48:10.027 に答える
11
また、元の質問で「foreach」メソッドを使用すると、反復中にリストからアイテムを削除できないなど、いくつかの制限があることに注意してください。
新しい for ループは読みやすく、別のイテレータの必要性を取り除きますが、読み取り専用の反復パスでのみ実際に使用できます。
于 2008-09-17T16:53:52.913 に答える
8
このようになります。非常に下品。
for (Iterator<String> i = someList.iterator(); i.hasNext(); )
System.out.println(i.next());
Sun のドキュメントには、for each に関する適切な説明があります。
于 2008-09-17T16:48:15.847 に答える
7
多くの良い答えが言ったように、ループ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キーワードの使用を an の使用に自動的に変換します。Iteratorこれは、 を実装していないオブジェクトがループを使用しようとするとIterable interfaceをスローする理由を説明している可能性があります。Exceptionfor-each
于 2016-11-29T03:20:27.020 に答える
5
public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
for(int k=0;k<totalsize;k++)
{
fullst.addAll();
}
}
于 2016-10-27T11:31:20.837 に答える
4
Java の for-each イディオムは、 *Iterable型の配列またはオブジェクトにのみ適用できます。このイディオムは、Iterator によって真に裏打ちされているため、暗黙的です。Iterator はプログラマによってプログラムされ、多くの場合、(データ構造に応じて) 整数インデックスまたはノードを使用してその位置を追跡します。紙の上では、通常の for ループよりも遅く、配列やリストなどの「線形」構造の場合は少なくとも遅くなりますが、より優れた抽象化を提供します。
于 2015-06-08T01:28:58.803 に答える