Appeler remove dans la boucle foreach en Java [dupliquer]

Vous ne voulez pas faire ça. Cela peut provoquer un comportement indéfini en fonction de la collection. Vous voulez utiliser unItérateur directement. Bien que pour chaque construction soit du sucre syntaxique et utilise vraiment un itérateur, il le cache de votre code afin que vous ne puissiez pas y accéder pour appeler Iterator.remove.

Le comportement d'un itérateur est non spécifié si le sous-jacent la collection est modifiée alors que le l'itération est en cours de quelque manière que ce soit d'autres que par l'appel de cette méthode.

Écrivez plutôt votre code:

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

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

Notez que le code appelle Iterator.remove, pas List.remove.

Additif:

Même si vous supprimez un élément qui n'a pas encore été itéré, vous ne voulez toujours pas modifier la collection, puis utiliser le Iterator. Cela pourrait modifier la collection d'une manière surprenante et affecter les opérations futures sur le Iterator.

La conception java de la "enhanced for loop" était de ne pas exposer l'itérateur au code, mais la seule façon de supprimer un élément en toute sécurité est d'accéder à l'itérateur. Donc, dans ce cas, vous devez le faire à l'ancienne:

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

Si dans le code réel, la boucle for améliorée en vaut vraiment la peine, vous pouvez ajouter les éléments à une collection temporaire et appeler removeAll sur la liste après la boucle.

EDIT (re addendum): Non, changer la liste de quelque manière que ce soit en dehors de l'itérateur.méthode remove() alors que l'itération causera des problèmes. Le seul moyen de contourner cela est d'utiliser une CopyOnWriteArrayList, mais qui est vraiment destiné aux problèmes de concurrence.

Le moyen le moins cher (en termes de lignes de code) de supprimer les doublons est de vider la liste dans un LinkedHashSet (puis de nouveau dans une liste si vous en avez besoin). Cela préserve l'ordre d'insertion tout en supprimant les doublons.

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

Vous clonez la liste names et parcourez le clone pendant que vous supprimez de la liste d'origine. Un peu plus propre que la réponse supérieure.

Je ne connaissais pas les itérateurs, mais voici ce que je faisais jusqu'à aujourd'hui pour supprimer des éléments d'une liste à l'intérieur d'une boucle:

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

Cela fonctionne toujours et pourrait être utilisé dans d'autres langages ou structures ne supportant pas les itérateurs.

Oui, vous pouvez utiliser la boucle for-each, Pour ce faire, vous devez maintenir une liste distincte pour contenir la suppression d'éléments, puis supprimer cette liste de la liste des noms en utilisant la méthode 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

Ceux qui disent que vous ne pouvez pas supprimer en toute sécurité un élément d'une collection sauf via l'itérateur ne sont pas tout à fait corrects, vous pouvez le faire en toute sécurité en utilisant l'une des collections concurrentes telles que ConcurrentHashMap.

Assurez-vous que ce n'est pas une odeur de code. Est-il possible d'inverser la logique et être "inclusif", plutôt que "d'exclusif"?

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

La situation qui m'a conduit à cette page impliquait un ancien code qui parcourait une liste en utilisant des indécies pour supprimer des éléments de la liste. Je voulais le refactoriser pour utiliser le style foreach.

Il a parcouru une liste complète d'éléments pour vérifier ceux auxquels l'utilisateur avait l'autorisation d'accéder, et a supprimé ceux qui n'avaient pas l'autorisation du liste.

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

Pour inverser cela et ne pas utiliser le remove:

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

Quand "supprimer" serait-il préféré? Une considération est si gien une grande liste ou cher "ajouter", combiné avec seulement quelques supprimé par rapport à la taille de la liste. Il pourrait être plus efficace de ne faire que quelques suppressions plutôt qu'un grand nombre d'ajouts. Mais dans mon cas, la situation ne méritait pas une telle optimisation.

1. Essayez ceci 2. et changez la condition en "HIVER" et vous vous demanderez:

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

, Il est préférable d'utiliser un Itérateur lorsque vous souhaitez supprimer l'élément de la liste

Parce que le code source de remove est

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

Donc ,si vous supprimez un élément de la liste, la liste sera restructurée ,l'index de l'autre élément sera modifié, cela peut entraîner quelque chose que vous voulez arriver.

Utiliser

.supprimer () d'Interator ou

Utiliser

CopyOnWriteArrayList