Llamando a remove en el bucle foreach en Java [duplicar]

No quieres hacer eso. Puede causar un comportamiento indefinido dependiendo de la colección. Desea utilizar un iterador directamente. Aunque para cada construcción es sugar sintáctico y realmente está usando un iterador, lo oculta de su código para que no pueda acceder a él para llamar Iterator.remove.

El comportamiento de un iterador es no especificado si el subyacente colección se modifica mientras que el iteración está en progreso de cualquier manera que no sea llamando a esto método.

En su lugar escriba su código:

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

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

Tenga en cuenta que el código llama Iterator.remove, no List.remove.

Adición:

Incluso si está eliminando un elemento que aún no se ha iterado, aún no desea modificar la colección y luego usar Iterator. Podría modificar la colección de una manera que es sorprendente y afecta a las operaciones futuras en el Iterator.

El diseño java del "enhanced for loop" era no exponer el iterador al código, pero la única manera de eliminar de forma segura un elemento es acceder al iterador. Así que en este caso tienes que hacerlo de la vieja escuela:

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

Si en el código real el bucle for mejorado realmente vale la pena, entonces podría agregar los elementos a una colección temporal y llamar a removeAll en la lista después del bucle.

EDIT (re addendum): No, cambiar la lista de cualquier manera fuera del iterador.método remove () mientras iterar causará problemas. La única manera de evitar esto es usar un CopyOnWriteArrayList, pero eso está realmente pensado para problemas de concurrencia.

La forma más barata (en términos de líneas de código) de eliminar duplicados es volcar la lista en un LinkedHashSet (y luego volver a una Lista si es necesario). Esto preserva el orden de inserción mientras elimina duplicados.

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

Clona la lista names e itera a través del clon mientras elimina de la lista original. Un poco más limpio que la respuesta principal.

No sabía acerca de los iteradores, sin embargo esto es lo que estaba haciendo hasta hoy para eliminar elementos de una lista dentro de un bucle:

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

Esto siempre está funcionando, y podría usarse en otros lenguajes o estructuras que no soporten iteradores.

Sí puede usar el bucle for-each, Para hacer eso, debe mantener una lista separada para mantener la eliminación de elementos y luego eliminar esa lista de la lista de nombres utilizando el método 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

Los que dicen que no se puede eliminar de forma segura un elemento de una colección, excepto a través del Iterador no son del todo correctos, puede hacerlo de forma segura utilizando una de las colecciones concurrentes, como ConcurrentHashMap.

Asegúrese de que esto no es olor a código. ¿Es posible invertir la lógica y ser "inclusivo" en lugar de "exclusivo"?

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

La situación que me llevó a esta página involucró un código antiguo que circulaba a través de una Lista usando indecies para eliminar elementos de la Lista. Quería refactorizarlo para usar el estilo foreach.

Recorrió una lista completa de elementos para verificar a cuáles tenía permiso de acceso el usuario, y eliminó los que no tenían permiso del lista.

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

Para invertir esto y no usar el remove:

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

¿Cuándo se prefiere "eliminar"? Una consideración es si gien una lista grande o caro "añadir", combinado con solo unos pocos eliminado en comparación con el tamaño de la lista. Podría ser más eficiente hacer solo unas pocas eliminaciones en lugar de una gran cantidad de adiciones. Pero en mi caso la situación no merecía tal optimización.

1. Prueba este 2. y cambia la condición a "INVIERNO" y te preguntarás:

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

Es mejor usar un iterador cuando se quiere eliminar un elemento de una lista

Porque el código fuente de remove es

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

Por lo tanto ,si elimina un elemento de la lista, la lista se reestructurará ,el índice del otro elemento se cambiará, esto puede resultar en algo que desea que suceda.

Use

.remove() de Interator o

Use

CopyOnWriteArrayList