Ich möchte in Java über eine Collection (hier List) mit einer for-Schleife (die Java1.5-Version davon) iterieren und bestimmte Elemente aus ihr entfernen, wenn ich gerade auf das Element gestoßen bin.

Was passiert dann aber mit der Schleife, wenn ich das Element entferne?
Wird das tatsächlich nächste Element (das was ohne Entfernung als nächste dran gewesen wäre) genommen? Wird dieses übersprungen (mit einer hochgezählten Indexvariablen würde das passieren)? Bricht die Schleife ab, obwohl noch Elemente zu iterieren wären?

Welche effiziente andere Lösung gäbe es, wenn eine der letzten beiden Möglichkeiten zutrifft?


Zur Veranschaulichung:

List<String> stringList = new ArrayList<String>();
... //befüllen der Liste
for(String str: stringList) {
  if (str.equals("hallo"))
    stringList.remove(str);
}

Christoph

Hallo,

EDIT: Hatte leider etwas zu viel Code aus der Antwort von cowabunga (die Liste vor dem iterieren kopieren) kopiert, so das alles was ich in der Original-Version sagte unnütz war. Hier die korrigierte Version (danke auch an Andreas für den subtilen Hinweis *g*). Es gibt wohl keine andere Wahl als den Iterator direkt zu verwenden.

import java.util.*;

public final class RandomListTest {
    public static void main(String[] args) {
        List<String> stringList =
            new ArrayList<String>(Arrays.asList("a", "hallo", "b"));

        for(Iterator<String> i=stringList.iterator(); i.hasNext();) {
            String str = i.next();
            System.out.printf("found element: %s\n", str);
            if (str.equals("hallo")) {
                i.remove();
            }
        }

        System.out.println(stringList);
    }
}

Die Ausgabe ist dann so:

found element: a
found element: hallo
found element: b
[a,b]

Du könntest statt einer foreach Schleife eine fori Schleife nutzen und die Collection von hinten beginnend durchlaufen.

List<String> stringList = new ArrayList<String>();
... //befüllen der Liste
for(int i = length - 1; i > -1; i--)
  if (str.get(i).equals("hallo"))
    stringList.remove(i);

Zur ursprünglichen Frage: Warum überhaupt selbst iterieren? Die Listen Implementierungen können das alle selbst, vorausgesetzt die Objekte der Liste implementieren equals() richtig, was aber im Fall der String Liste gegeben ist.

List<String> stringList = new ArrayList<String>();
... //befüllen der Liste
stringList.remove("hallo");

Oder, falls das Fragliche Objekt mehrfach vorkommt:

List<String> stringList = new ArrayList<String>();
... //befüllen der Liste
while(stringList.remove("hallo"))
{}

Falls Du Elemente aus der List löschen möchtest kannst Du es so implementieren:

List<String> stringList = new ArrayList<String>();
... //befüllen der Liste
for(String str: new LinkedList<String>(stringList)) {
  if (str.equals("hallo"))
    stringList.remove(str);
}

Natürlich geht das nicht, dürfte in keiner Programmiersprache gehen meines Wissens.
Als alternative könntest du die Liste clonen oder eine LinkedList nehmen.

Grüßle

PS: ups da war cowabunga schneller...sorry habs nicht gesehen.