iteriert durch die ArrayList<T> java?

Gibt es zwei Möglichkeiten, dies zu tun:

1. Eine for Schleife
2. Mit der iterator Methode.

for Schleife:

for(x currentX : GetList()) {
    //Do something with the value
}

Dies ist, was genannt wird eine "for-each" - Schleife, und es ist wahrscheinlich die meisten common/bevorzugte Methode, dies zu tun. Die syntax ist:

for(ObjectType variableName : InCollection)

Können Sie auch ein standard - for Schleife:

ArrayList<x> list = GetList();
for(int i=0; i<list.size(); i++) {
     x currentX = list.get(i);
     //Do something with the value
 }

Die syntax HIERFÜR lautet:

for(someStartingValue; doSomethingWithStartingValue; conditionToStopLooping)

iterator Methode:

Iterator<x> iterator = GetList().iterator();
while(iterator.hasNext()) {
    x currentX = iterator.next();
    //Do something with the value
}

Ich denke, man kann Durchlaufen der arraylist eine Reihe von Möglichkeiten. Eine Möglichkeit ist der iterator:-

ArrayList<String> al = new ArrayList<String>();

al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");

System.out.print("Original contents of al: ");
Iterator<String> itr = al.iterator();
while (itr.hasNext()) {
  String element = itr.next();
  System.out.print(element + " ");
}

Andere Möglichkeit wäre eine Schleife:

for(int i = 0; i < list.size(); i++){
    list[i].a = 29;
}

Hoffe das hilft in irgendeiner Weise.

Ref

http://www.tutorialspoint.com/java/java_using_iterator.htm

http://examples.javacodegeeks.com/core-java/util/arraylist/arraylist-in-java-example-how-to-use-arraylist/

UPDATE

Dachte ich, dass ich einfach setzen diese draußen aus der Forschung durch den Kommentar unten über die Leistung.

Die Android-docs

http://developer.android.com/training/articles/perf-tips.html

Staaten:

Die erweiterte for-Schleife (manchmal auch bekannt als "for-each" - Schleife) können verwendet werden, für die Sammlungen >, implementieren die Schnittstelle Durchsuchbar und für arrays. Mit Sammlungen, ein iterator >zugeordnet, um interface-Aufrufe von hasNext() und next(). Mit einer ArrayList, eine hand-schriftliche >gezählte Schleife ist ungefähr 3x schneller (mit oder ohne JIT), sondern auch für andere Sammlungen, die enhanced >for-Schleife syntax ist exakt äquivalent zur expliziten iterator-Verwendung.

Gibt es mehrere alternativen für die Iteration durch ein array:

static class Foo {
    int mSplat;
}

Foo[] mArray = ...

public void zero() {
    int sum = 0;
    for (int i = 0; i < mArray.length; ++i) {
        sum += mArray[i].mSplat;
    }
}

public void one() {
    int sum = 0;
    Foo[] localArray = mArray;
    int len = localArray.length;

    for (int i = 0; i < len; ++i) {
        sum += localArray[i].mSplat;
    }
}

public void two() {
    int sum = 0;
    for (Foo a : mArray) {
        sum += a.mSplat;
    }
}

• null() am langsamsten ist, weil der JIT kann nicht noch optimieren entfernt die Kosten, um die array-Länge, einmal für jede iteration der
  loop.

• eine() ist schneller. Es zieht alles in die lokalen Variablen,
  die Vermeidung der lookups. Nur der array-Länge und bietet eine Leistung
  profitieren.

• zwei() ist die Schnellste, für Geräte ohne JIT, und nicht zu unterscheiden
  aus ein() für Geräte mit JIT. Es verwendet die erweiterte for-Schleife
  syntax eingeführt in version 1.5 der Java-Programmiersprache.

Also, sollten Sie die Nutzung der erweiterten for-Schleife standardmäßig, aber halte eine hand-schriftliche gezählte Schleife for-performance-kritische ArrayList-iteration. Auch dies wird durch Josh Bloch Effektiv Java, Artikel 46. Der iterator und die index-Variablen sind beide nur Durcheinander. Zudem sind die Chancen für Fehler.

Der am günstigsten gelegene idioms für Iteration über collections und arrays

for(Element e : elements){
    doSomething(e);
}

Josh auch Staaten, wenn Sie sehen,, der Doppelpunkt : Lesen Sie es als "In". Die Schleife liest sich so als für jedes element e in elements. Ich behaupte nicht, die diese Arbeit als meine eigene, obwohl ich wünschte, es war. Wenn Sie mehr darüber erfahren möchten, effizienten code dann schlage ich die Lektüre Josh Bloch Effektiv Java.