Iterando a través de una colección, evitando ConcurrentModificationException al eliminar objetos en un bucle

Todos sabemos que no puede hacer lo siguiente por ConcurrentModificationException:

for (Object i : l) {
    if (condition(i)) {
        l.remove(i);
    }
}

Pero esto aparentemente funciona a veces, pero no siempre. Aquí hay un código específico:

public static void main(String[] args) {
    Collection<Integer> l = new ArrayList<>();

    for (int i = 0; i < 10; ++i) {
        l.add(4);
        l.add(5);
        l.add(6);
    }

    for (int i : l) {
        if (i == 5) {
            l.remove(i);
        }
    }

    System.out.println(l);
}

Esto, por supuesto, da como resultado:

Exception in thread "main" java.util.ConcurrentModificationException

A pesar de que múltiples hilos no lo están haciendo. De todas formas.

¿Cuál es la mejor solución para este problema? ¿Cómo puedo eliminar un elemento de la colección en un bucle sin lanzar esta excepción?

También estoy usando un arbitrario Collectionaquí, no necesariamente un ArrayList, por lo que no puede confiar get.

Iterator.remove() es seguro, puedes usarlo así:

List<String> list = new ArrayList<>();

// This is a clever way to create the iterator and call iterator.hasNext() like
// you would do in a while-loop. It would be the same as doing:
//     Iterator<String> iterator = list.iterator();
//     while (iterator.hasNext()) {
for (Iterator<String> iterator = list.iterator(); iterator.hasNext();) {
    String string = iterator.next();
    if (string.isEmpty()) {
        // Remove the current element from the iterator and the list.
        iterator.remove();
    }
}

Tenga en cuenta que Iterator.remove()es la única forma segura de modificar una colección durante la iteración; el comportamiento no se especifica si la colección subyacente se modifica de alguna otra manera mientras la iteración está en progreso.

Fuente: docs.oracle> La interfaz de la colección

Y de manera similar, si tiene un ListIteratory desea agregar elementos, puede usarListIterator#add , por la misma razón que puede Iterator#remove hacerlo: está diseñado para permitirlo.

En su caso se trató de eliminar de una lista, pero la misma restricción se aplica si intentara puten un Mapmientras que la iteración de su contenido.

Esto funciona:

Iterator<Integer> iter = l.iterator();
while (iter.hasNext()) {
    if (iter.next() == 5) {
        iter.remove();
    }
}

Supuse que, dado que un bucle foreach es azúcar sintáctico para iterar, usar un iterador no ayudaría ... pero le brinda esta .remove()funcionalidad.

Con Java 8 puede usar el nuevo removeIfmétodo . Aplicado a tu ejemplo:

Collection<Integer> coll = new ArrayList<>();
//populate

coll.removeIf(i -> i == 5);

Dado que la pregunta ya ha sido respondida, es decir, la mejor manera es usar el método remove del objeto iterador, entraría en los detalles del lugar donde "java.util.ConcurrentModificationException"se arroja el error .

Cada clase de colección tiene una clase privada que implementa la interfaz Iterator y proporciona métodos como next(), remove()y hasNext().

El código para el siguiente se parece a esto ...

public E next() {
    checkForComodification();
    try {
        E next = get(cursor);
        lastRet = cursor++;
        return next;
    } catch(IndexOutOfBoundsException e) {
        checkForComodification();
        throw new NoSuchElementException();
    }
}

Aquí el método checkForComodificationse implementa como

final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

Entonces, como puede ver, si intenta explícitamente eliminar un elemento de la colección. Resulta modCountdiferente de expectedModCount, lo que resulta en la excepción ConcurrentModificationException.

Puede usar el iterador directamente como lo mencionó, o bien mantener una segunda colección y agregar cada elemento que desea eliminar a la nueva colección, luego eliminar todo al final. Esto le permite seguir usando la seguridad de tipo del bucle para cada uno a costa de un mayor uso de memoria y tiempo de CPU (no debería ser un gran problema a menos que tenga listas realmente grandes o una computadora realmente vieja)

public static void main(String[] args)
{
    Collection<Integer> l = new ArrayList<Integer>();
    Collection<Integer> itemsToRemove = new ArrayList<>();
    for (int i=0; i < 10; i++) {
        l.add(Integer.of(4));
        l.add(Integer.of(5));
        l.add(Integer.of(6));
    }
    for (Integer i : l)
    {
        if (i.intValue() == 5) {
            itemsToRemove.add(i);
        }
    }

    l.removeAll(itemsToRemove);
    System.out.println(l);
}

En tales casos, un truco común es (¿era?) Ir hacia atrás:

for(int i = l.size() - 1; i >= 0; i --) {
  if (l.get(i) == 5) {
    l.remove(i);
  }
}

Dicho esto, estoy más que feliz de que tenga mejores formas en Java 8, por ejemplo, removeIfo filteren las transmisiones.

Misma respuesta que Claudio con un bucle for:

for (Iterator<Object> it = objects.iterator(); it.hasNext();) {
    Object object = it.next();
    if (test) {
        it.remove();
    }
}

Con Eclipse Collections , el método removeIfdefinido en MutableCollection funcionará:

MutableList<Integer> list = Lists.mutable.of(1, 2, 3, 4, 5);
list.removeIf(Predicates.lessThan(3));
Assert.assertEquals(Lists.mutable.of(3, 4, 5), list);

Con la sintaxis Lambda de Java 8, esto se puede escribir de la siguiente manera:

MutableList<Integer> list = Lists.mutable.of(1, 2, 3, 4, 5);
list.removeIf(Predicates.cast(integer -> integer < 3));
Assert.assertEquals(Lists.mutable.of(3, 4, 5), list);

La llamada a Predicates.cast()es necesaria aquí porque removeIfse agregó un método predeterminado en la java.util.Collectioninterfaz en Java 8.

Nota: Soy un committer para Eclipse Collections .

Haga una copia de la lista existente e itere sobre una nueva copia.

for (String str : new ArrayList<String>(listOfStr))     
{
    listOfStr.remove(/* object reference or index */);
}

Las personas afirman que no se puede eliminar de una Colección que se repite por un bucle foreach. Solo quería señalar que es técnicamente incorrecto y describir exactamente (sé que la pregunta del OP es tan avanzada como para evitar saber esto) el código detrás de esa suposición:

for (TouchableObj obj : untouchedSet) {  // <--- This is where ConcurrentModificationException strikes
    if (obj.isTouched()) {
        untouchedSet.remove(obj);
        touchedSt.add(obj);
        break;  // this is key to avoiding returning to the foreach
    }
}

No es que no pueda eliminar de la Colletioniteración, sino que no puede continuar la iteración una vez que lo hace. Por lo tanto, labreak en el código anterior.

Disculpas si esta respuesta es un caso de uso algo especializado y más adecuado para el hilo original del que llegué aquí, ese está marcado como duplicado (a pesar de que este hilo parece más matizado) de esto y bloqueado.

Con un bucle tradicional

ArrayList<String> myArray = new ArrayList<>();

for (int i = 0; i < myArray.size(); ) {
    String text = myArray.get(i);
    if (someCondition(text))
        myArray.remove(i);
    else
        i++;   
}

A le ListIteratorpermite agregar o eliminar elementos en la lista. Supongamos que tiene una lista de Carobjetos:

List<Car> cars = ArrayList<>();
// add cars here...

for (ListIterator<Car> carIterator = cars.listIterator();  carIterator.hasNext(); )
{
   if (<some-condition>)
   { 
      carIterator().remove()
   }
   else if (<some-other-condition>)
   { 
      carIterator().add(aNewCar);
   }
}

Tengo una sugerencia para el problema anterior. No necesita lista secundaria ni tiempo extra. Encuentre un ejemplo que haga lo mismo pero de manera diferente.

//"list" is ArrayList<Object>
//"state" is some boolean variable, which when set to true, Object will be removed from the list
int index = 0;
while(index < list.size()) {
    Object r = list.get(index);
    if( state ) {
        list.remove(index);
        index = 0;
        continue;
    }
    index += 1;
}

Esto evitaría la excepción de concurrencia.

ConcurrentHashMap o ConcurrentLinkedQueue o ConcurrentSkipListMap puede ser otra opción, porque nunca arrojarán ninguna ConcurrentModificationException, incluso si elimina o agrega un elemento.

Sé que esta pregunta es demasiado antigua para ser sobre Java 8, pero para aquellos que usan Java 8, pueden usar removeIf () fácilmente:

Collection<Integer> l = new ArrayList<Integer>();

for (int i=0; i < 10; ++i) {
    l.add(new Integer(4));
    l.add(new Integer(5));
    l.add(new Integer(6));
}

l.removeIf(i -> i.intValue() == 5);

Otra forma es crear una copia de su arrayList:

List<Object> l = ...

List<Object> iterationList = ImmutableList.copyOf(l);

for (Object i : iterationList) {
    if (condition(i)) {
        l.remove(i);
    }
}

La mejor manera (recomendada) es el uso del paquete java.util.Concurrent. Al usar este paquete, puede evitar fácilmente esta excepción. referir código modificado

public static void main(String[] args) {
    Collection<Integer> l = new CopyOnWriteArrayList<Integer>();

    for (int i=0; i < 10; ++i) {
        l.add(new Integer(4));
        l.add(new Integer(5));
        l.add(new Integer(6));
    }

    for (Integer i : l) {
        if (i.intValue() == 5) {
            l.remove(i);
        }
    }

    System.out.println(l);
}

En el caso de ArrayList: remove (int index) - if (index es la posición del último elemento) evita sin System.arraycopy()y no toma tiempo para esto.

el tiempo de la matriz aumenta si (el índice disminuye), por cierto, los elementos de la lista también disminuyen.

la mejor manera efectiva de eliminar es eliminar sus elementos en orden descendente: while(list.size()>0)list.remove(list.size()-1);// toma O (1) while(list.size()>0)list.remove(0);// toma O (factorial (n))

//region prepare data
ArrayList<Integer> ints = new ArrayList<Integer>();
ArrayList<Integer> toRemove = new ArrayList<Integer>();
Random rdm = new Random();
long millis;
for (int i = 0; i < 100000; i++) {
    Integer integer = rdm.nextInt();
    ints.add(integer);
}
ArrayList<Integer> intsForIndex = new ArrayList<Integer>(ints);
ArrayList<Integer> intsDescIndex = new ArrayList<Integer>(ints);
ArrayList<Integer> intsIterator = new ArrayList<Integer>(ints);
//endregion

// region for index
millis = System.currentTimeMillis();
for (int i = 0; i < intsForIndex.size(); i++) 
   if (intsForIndex.get(i) % 2 == 0) intsForIndex.remove(i--);
System.out.println(System.currentTimeMillis() - millis);
// endregion

// region for index desc
millis = System.currentTimeMillis();
for (int i = intsDescIndex.size() - 1; i >= 0; i--) 
   if (intsDescIndex.get(i) % 2 == 0) intsDescIndex.remove(i);
System.out.println(System.currentTimeMillis() - millis);
//endregion

// region iterator
millis = System.currentTimeMillis();
for (Iterator<Integer> iterator = intsIterator.iterator(); iterator.hasNext(); )
    if (iterator.next() % 2 == 0) iterator.remove();
System.out.println(System.currentTimeMillis() - millis);
//endregion

• para el índice de bucle: 1090 ms
• para el índice desc: 519 mseg --- el mejor
• para iterador: 1043 ms

for (Integer i : l)
{
    if (i.intValue() == 5){
            itemsToRemove.add(i);
            break;
    }
}

El truco es después de eliminar el elemento de la lista si omite la llamada interna iterator.next (). ¡aún funciona! Aunque no propongo escribir código como este, ayuda a entender el concepto detrás de él :-)

¡Salud!

Ejemplo de modificación de colección segura para subprocesos:

public class Example {
    private final List<String> queue = Collections.synchronizedList(new ArrayList<String>());

    public void removeFromQueue() {
        synchronized (queue) {
            Iterator<String> iterator = queue.iterator();
            String string = iterator.next();
            if (string.isEmpty()) {
                iterator.remove();
            }
        }
    }
}

Sé que esta pregunta supone solo una Collection, y no más específicamente ninguna List. Pero para aquellos que leen esta pregunta que realmente están trabajando con una Listreferencia, puede evitar ConcurrentModificationExceptioncon un whilebucle (mientras modifica dentro de ella) si quiere evitarloIterator (ya sea si desea evitarlo en general o evitarlo específicamente para lograr un orden de bucle diferente de principio a fin que se detiene en cada elemento [que creo que es el único orden que Iteratorpuede hacer]):

* Actualización: vea los comentarios a continuación que aclaran que lo análogo también se puede lograr con el tradicional para bucle.

final List<Integer> list = new ArrayList<>();
for(int i = 0; i < 10; ++i){
    list.add(i);
}

int i = 1;
while(i < list.size()){
    if(list.get(i) % 2 == 0){
        list.remove(i++);

    } else {
        i += 2;
    }
}

Sin ConcurrentModificationException de ese código.

Allí vemos que el bucle no comienza desde el principio y no se detiene en cada elemento (lo que creo Iteratorque no puede hacer).

FWIW también vemos que getse llama list, lo que no se podría hacer si su referencia fuera solo Collection(en lugar del Listtipo más específico de Collection): la Listinterfaz incluye get, pero la Collectioninterfaz no. Si no fuera por esa diferencia, entonces la listreferencia podría ser una Collection[y, por lo tanto, técnicamente esta respuesta sería una respuesta directa, en lugar de una respuesta tangencial].

El mismo código FWIWW sigue funcionando después de la modificación para comenzar al principio en cada elemento (al igual que el Iteratororden):

final List<Integer> list = new ArrayList<>();
for(int i = 0; i < 10; ++i){
    list.add(i);
}

int i = 0;
while(i < list.size()){
    if(list.get(i) % 2 == 0){
        list.remove(i);

    } else {
        ++i;
    }
}

Una solución podría ser rotar la lista y eliminar el primer elemento para evitar la ConcurrentModificationException o IndexOutOfBoundsException

int n = list.size();
for(int j=0;j<n;j++){
    //you can also put a condition before remove
    list.remove(0);
    Collections.rotate(list, 1);
}
Collections.rotate(list, -1);

Pruebe este (elimina todos los elementos de la lista que sean iguales i):

for (Object i : l) {
    if (condition(i)) {
        l = (l.stream().filter((a) -> a != i)).collect(Collectors.toList());
    }
}

también puedes usar Recursion

La recursión en Java es un proceso en el cual un método se llama a sí mismo continuamente. Un método en Java que se llama a sí mismo se llama método recursivo.

esta podría no ser la mejor manera, pero para la mayoría de los casos pequeños esto debería ser aceptable:

"crea una segunda matriz vacía y agrega solo las que quieras conservar"

_{No recuerdo de dónde leí esto ... para ser justos, haré este wiki con la esperanza de que alguien lo encuentre o simplemente para no ganar reputación que no merezco.}