Chiamata remove in foreach loop in Java [duplicate]

Non vuoi farlo. Può causare un comportamento indefinito a seconda della raccolta. Si desidera utilizzare direttamente un iteratore . Sebbene per ogni costrutto sia zucchero sintattico e stia davvero usando un iteratore, lo nasconde dal tuo codice in modo da non poterlo accedere alla chiamata Iterator.remove.

Il comportamento di un iteratore è non specificato se il sottostante la raccolta viene modificata mentre il l'iterazione è in corso in qualsiasi modo oltre a chiamare questo metodo.

Invece scrivi il tuo codice:

List<String> names = ....
Iterator<String> it = names.iterator();
while (it.hasNext()) {

    String name = it.next();
    // Do something
    it.remove();
}

Si noti che il codice chiama Iterator.remove, non List.remove.

Addendum:

Anche se stai rimuovendo un elemento che non è stato ancora iterato, non vuoi ancora modificare la raccolta e quindi utilizzare Iterator. Potrebbe modificare la raccolta in un modo sorprendente e influenzare le operazioni future sul Iterator.

Il design java di "enhanced for loop" consisteva nel non esporre l'iteratore al codice, ma l'unico modo per rimuovere in modo sicuro un elemento è accedere all'iteratore. Quindi in questo caso devi farlo vecchia scuola:

 for(Iterator<String> i = names.iterator(); i.hasNext();) {
       String name = i.next();
       //Do Something
       i.remove();
 }

Se nel codice reale il ciclo for avanzato vale davvero la pena, è possibile aggiungere gli elementi a una raccolta temporanea e chiamare removeAll nell'elenco dopo il ciclo.

EDIT (re addendum): No, cambiando l'elenco in qualsiasi modo al di fuori dell'iteratore.remove () metodo mentre l'iterazione causerà problemi. L'unico modo per aggirare questo è usare un CopyOnWriteArrayList, ma che è davvero destinato a problemi di concorrenza.

Il modo più economico (in termini di righe di codice) per rimuovere i duplicati è scaricare l'elenco in un LinkedHashSet (e poi di nuovo in un elenco se necessario). Questo mantiene l'ordine di inserimento durante la rimozione dei duplicati.

for (String name : new ArrayList<String>(names)) {
    // Do something
    names.remove(nameToRemove);
}

Clonare l'elenco names e scorrere il clone mentre si rimuove dall'elenco originale. Un po ' più pulito della risposta migliore.

Non sapevo degli iteratori, tuttavia ecco cosa stavo facendo fino ad oggi per rimuovere elementi da una lista all'interno di un ciclo:

List<String> names = .... 
for (i=names.size()-1;i>=0;i--) {    
    // Do something    
    names.remove(i);
} 

Funziona sempre e potrebbe essere utilizzato in altri linguaggi o strutture che non supportano gli iteratori.

Sì è possibile utilizzare il ciclo for-each, Per fare ciò è necessario mantenere un elenco separato per contenere la rimozione di elementi e quindi rimuovere tale elenco dall'elenco dei nomi utilizzando il metodo removeAll(),

List<String> names = ....

// introduce a separate list to hold removing items
List<String> toRemove= new ArrayList<String>();

for (String name : names) {
   // Do something: perform conditional checks
   toRemove.add(name);
}    
names.removeAll(toRemove);

// now names list holds expected values

Coloro che dicono che non è possibile rimuovere in modo sicuro un elemento da una raccolta tranne che attraverso l'Iteratore non sono del tutto corretti, è possibile farlo in modo sicuro utilizzando una delle raccolte simultanee come ConcurrentHashMap.

Assicurati che questo non sia odore di codice. È possibile invertire la logica ed essere "inclusivi" piuttosto che "esclusivi"?

List<String> names = ....
List<String> reducedNames = ....
for (String name : names) {
   // Do something
   if (conditionToIncludeMet)
       reducedNames.add(name);
}
return reducedNames;

La situazione che mi ha portato a questa pagina ha coinvolto il vecchio codice che scorreva attraverso una lista usando indecies per rimuovere gli elementi dalla lista. Volevo rifattorizzarlo per usare lo stile foreach.

Ha eseguito il loop di un intero elenco di elementi per verificare a quali utenti era consentito accedere e ha rimosso quelli che non avevano elenco.

List<Service> services = ...
for (int i=0; i<services.size(); i++) {
    if (!isServicePermitted(user, services.get(i)))
         services.remove(i);
}

Per invertire questo e non utilizzare il remove:

List<Service> services = ...
List<Service> permittedServices = ...
for (Service service:services) {
    if (isServicePermitted(user, service))
         permittedServices.add(service);
}
return permittedServices;

Quando sarebbe preferibile "rimuovi"? Una considerazione è se gien una grande lista o costoso "add", combinato con solo pochi rimosso rispetto alla dimensione della lista. Potrebbe essere più efficiente fare solo alcune rimuove piuttosto che un gran numero di aggiunge. Ma nel mio caso la situazione non meritava una tale ottimizzazione.

1. Prova questo 2. e cambia la condizione in "INVERNO" e ti chiederai:

public static void main(String[] args) {
  Season.add("Frühling");
  Season.add("Sommer");
  Season.add("Herbst");
  Season.add("WINTER");
  for (String s : Season) {
   if(!s.equals("Sommer")) {
    System.out.println(s);
    continue;
   }
   Season.remove("Frühling");
  }
 }

È meglio usare un iteratore quando si desidera rimuovere l'elemento da un elenco

Perché il codice sorgente di remove è

if (numMoved > 0)
    System.arraycopy(elementData, index+1, elementData, index,
             numMoved);
elementData[--size] = null;

Quindi ,se rimuovi un elemento dall'elenco, l'elenco verrà ristrutturato ,l'indice dell'altro elemento verrà modificato, questo può risultare qualcosa che vuoi accadere.

Utilizzare

.remove () di Interator o

Utilizzare

Elenco di CopyOnWriteArrayList