どのようなJava"コン'ループ。

https://stackoverflow.com/questions/85190

01-07-2019
|

質問

発生していると考えること

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

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

うのに相当 for ループのように見えなし各文?

解決

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

ることがありますのでご注意くだを使用する必要が i.remove(); ごループは、アクセスの反復子に何らかの方法では利用できません for ( : ) 熟年の実際の反復子は単なると推定される。

指摘されたようにドニBuenoのこのコードを作のanyオブジェクトを実装する Iterable インタ.

また、右側の for (:) 熟である array というよりむしろ Iterable オブジェクトの内部コードを使用してint indexカウンターとチェック対 array.length です。を参照 "Java言語仕様.

他のヒント

の構築各も有効でarrays.例えば

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);
}
ることがありますのでご注意くだを使用する必要がん。remove();ごループは、アクセス実際の反復子の一部、ミズナラ、モミジなどの新緑と利用できない、(:)音、実際の反復子であと推定される。

[ドニBueno]

で示唆するnsayerの回答がこのことは特筆に値するのOPのために(..) 構文ですが"someList"が何を実装する java.lang.List--ることはないという感じできリスト、コレクションから java.util.でも自分の種類そのため、することができます。構文です。

の foreach ループ, 加 Java5 するとともに"強化されたループ"）は、相当の使用 java.util.Iterator--その統語砂糖のため同じものだと言ってもいいです。そのため、読み込み時には、各要素の一つ一つのためには、 foreach 必ず選び反復子は、そのまま利便性及び簡潔でなければならない。

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 この場合にはindexable物、アクセスできないの。る場合を例に基 for ループが必要です:

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

がきを作成しよう別int index-変数 foreach,

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

をお勧めしませんか可変範囲ない理想の基礎 for ループは単純に標準期待される形式を利用することを考えます。

`foreach` 対 `for`:性能

アクセス時に回収し、 foreach はを大幅に高速化以上の基礎 for ループ配列にアクセス。アクセス時に配列しもとプリミティブラッパー-配列--アクセス指数が大幅に早くなるのです。

タイミングの違いを反復子およびインデックスアクセスのためのプリミティブなint配列

インデックスは23日40 ％よりも早く反復子の場合、アクセス int または Integer arrays.ここからの出力試験クラスの底する金額の100要素をプリミティブ-int配列が繰り返し処理する反復子であり、Ｂは指数):

[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配列のテストクラス:

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)

一つの試験は彼らとほぼ同等がコレクション、反復子が勝利した。

※この投稿は"と"どちらかと言えば、私にスタックオーバーフロー:

一部情報: 効率は、各ループは、反復子?

の試験クラス

この比較の間でかい-せ-つものクラスを読むこの質問にスタックオーバーフロー:

import  java.text.NumberFormat;
import  java.util.Locale;

/**
   &lt;P&gt;{@code java TimeIteratorVsIndexIntArray 1000000}&lt;/P&gt;

   @see  &lt;CODE&gt;&lt;A HREF=&quot;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&quot;&gt;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&lt;/A&gt;&lt;/CODE&gt;
 **/
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.で精密なものでは有のための教育を行う。

プログラミングがしたネット環境さえあればコードは、以下に示すようになります:

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のListインタフェース。

のための各ループにJavaの基反復子機構。このと同一の

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

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

Javaの8機能を使用できます:

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

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

出力

First
Second
Third

で示唆するnsayerの答えがここで注目されるのOPのために(..)構文ですが"someList"が何を実装したjava.lang.Listいてリスト、コレクションからjava.util.でも自分の種類、そのため、使用できるこの構文です。

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

そのダンプを、コンソールには以下になります。

hello
2 is cool
hello
hello

として定義される環太平洋ののための各ループでは二つの形

場合には表現であるサブタイプの 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);
}

されたものは、配列型 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);
}

Java8を紹介して流を行う一般的です。利用できました:

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

Java"のために-それぞれのループ構築を繰り返し処理の二種類のオブジェクト

T[] (配列の種類)
java.lang.Iterable<T>

の Iterable<T> インターフェースの一方法: Iterator<T> iterator().このオブジェクトの型 Collection<T> なので Collection<T> インタフェース Iterable<T>.

の概念をforeachで商品情報を順次取得してWikipediaにはハイライトされます。

とは異なりそのためループを構築しますが、foreachループ通常維持 不明示的にカウンター:彼らは基本的に"かというとこもこのセット"よりも"このx"です。これを回避潜在 off-by-one誤差 は、コードを簡単になります。

その概念をforeachで商品情報を順次取得られている記述のループを使っていないので明示的にカウンターとの必要はありません索引を利用するトラバースのリストでの保存ユーザー off-by-oneエラーになります。つのコンセプトのこの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ループを実行します。

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

こちらは同等の表現です。

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

また、"foreach"法の質問には一部制限することができなかった、という除項目リストからの中になります。

のためのループが読みやすくなり除去する必要が別々の反復子がにのみ使用できる読み取り専用の繰り返します。

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

代替forEachを避けるための"ぞ":

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

Variant1(無地):

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

Variant2(ルチコアcpuを生かして並列実行(高速)):

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

この美しいコードを取り除きすべての基本的なループを採用。この見た目をコードを正当化されます。

通常の for ループ：

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

のための各 は構築に渡るコレクションを実装し 反復子.覚えていること、あなたのコレクションを実施するべきである 反復子;その他は使用できなくなった。

以下の線ることを目的としています"各TimerTask t一覧です。"

for (TimerTask t : list)

あの少ないエラーの場合に用います。んなの心配を初期化する反復子は初期化ループのカウンターを終了する(ある範囲のための誤りのない）

Java8をいち早く導入し、forEach.利用でリスト地図で繰り返し再生.

ループの一覧をご

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

ストとの同時購入で今ならこれ。非常にcrufty.

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

あwriteupに各の日文書.

前のJava8を利用する必要があり、以下の:

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

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

しかしながら、導入の流れをJava8でも同じようにも少ない構文です。例えば、お someList ことができるの?

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

また、この約の流れこちらの.

として数多くの回答となり、オブジェクトを実装する必要の 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 を逆コンパイルこのクラスを取得しますbytecodeサンプル

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 ループを実行します。

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

の Java各ループ (通称性のためのループ)が簡易版のためのループを実行します。の適用が少ないコードを書くと以下の変数に管理いたします。の下振れであるとともに、制御のステップ値へのアクセスループindexのループ。

彼らはベストを使用するステップ値が単純値が1のときにのみアクセスする必要の現在のループ要素となります。例えば、必要なループ以上の全ての要素が配列やコレクションなしに覗いてみたら先または裏手の現在の要素となります。

がループの初期化は、booleanのステップ値が暗黙的には簡単な増加.これは何なのか考えるようにより正規のためのタイルです。

拡張forループをこの順に実行:

1)ループ本体

2)繰り返しからステップ1で全配列または指定されています。トラバース

例の整数型配列

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

のcurrentValue変数の現在の値がループをintArray配列になります。通知が明示的なステップ値で常に増加により1.

コロンとすることが考えられることはできないもの"にございます。の強化のためのループを宣言：ループ以上intArrayを現在の配列をint値にのcurrentValue可変となります。

出力：

例–文字列配列

また利用のための各ループに対して繰り返し処理を実行するstring配列です。ループを宣言：ループ以上myStrings文字列配列を現在の文字列値にのcurrentString可変となります。

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

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

出力：

alpha
beta
gamma
delta

例一覧

の強化のためのループで使用することもに対して繰り返し処理を実行するjava.util.リストとして

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

例セット

の強化のためのループで使用することもに対して繰り返し処理を実行するjava.util.は以下のようになっている:

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可変となります。ここでは、重複した文字列がないかどうかについて合理的な保存されます。

出力：

alpha
delta
beta
gamma

ソース：ループからJava–菓子業界に絶大な支持を受け

Javaのための各イディオムに対してのみ適用できることで配列やオブジェクトの型 *List.この音は 暗黙的な で真に密着性に裏付けられたIterator.の反復子がプログラムのプログラマが使用する整数インデックスまたはノードによってデータ構造のイラストの位置を一定に保持します。紙では以下の通常のループは、少なくとも"線"のような建造物アレイやリストだけでより可能です。

この見が激しこんにちはで

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

この作品。 マジック

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

を繰り返して調べてのすべてのオブジェクト項目の表に示す。

ライセンス： CC-BY-SA と帰属

所属していません StackOverflow