Appel supprimer dans la boucle foreach en Java [dupliquer]

tu ne veux pas faire ça. Il peut causer un comportement non défini en fonction de la collection. Vous voulez utiliser un Iterator directement. Bien que le pour chaque construction est du sucre syntaxique et utilise vraiment un itérateur, il le cache de votre code de sorte que vous ne pouvez pas y accéder pour appeler Iterator.remove .

Le comportement d'un itérateur est non spécifié si le sous-jacent la collecte est modifiée pendant que le l'itération en cours, en quelque sorte d'autres que par l'appel de cette méthode.

à la place écrivez 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 et non List.remove .

Addendum:

même si vous supprimez un élément qui n'a pas encore été itéré, vous ne voulez pas modifier la collection et ensuite utiliser le Iterator . Il pourrait modifier la collection d'une manière qui surprend et affecte les opérations futures sur le Iterator .

la conception java du" 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 enhanced for vaut vraiment la peine, alors vous pouvez ajouter les éléments à une collection temporaire et appeler removeAll sur la liste après la boucle.

MODIFIER (re addendum): Non, la modification de la liste en quelque sorte en dehors de l'itérateur.méthode remove() lors de l'itération va causer des problèmes. La seule façon d'éviter cela est d'utiliser un CopyOnWriteArrayList, mais qui est vraiment destiné à des questions de concurrence.

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

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

vous clonez la liste names et itérez à travers le clone pendant que vous retirez de la liste originale. Un peu plus propre que la réponse sommet.

Je ne savais pas à propos des 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 langues ou structures ne supportant pas les itérateurs.

Oui vous pouvez utiliser la boucle pour chaque, Pour ce faire, vous devez maintenir une liste séparée pour tenir supprimer des articles et puis supprimer cette liste de la liste des noms en utilisant removeAll() méthode,

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 retirer un article d'une collection en toute sécurité sauf par 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 Competienthashmap.

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 vieux code qui a fait un tour dans une liste en utilisant des indecies pour supprimer des éléments de la liste. Je voulais le reformuler pour qu'il utilise le style foreach.

il a passé en boucle une liste complète d'éléments pour vérifier lesquels l'utilisateur avait la permission d'accéder, et a supprimé ceux qui n'ont pas la permission de la liste.

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

pour inverser cette ET NE PAS utiliser le supprimer:

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érable? Une considération est si gien une grande liste ou cher "ajouter", combiné avec seulement quelques enlevés 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'additions. Mais dans mon cas, la situation ne mérite 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 voulez supprimer un élément d'une 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 restructurer ,l'autre de l'élément d'index sera modifié, il peut en résulter quelque chose que vous voulez est arrivé.

Utiliser

.Supprimer () de L'Interator ou

Utiliser

CopyOnWriteArrayList