ConcurrentModificationException al usar Iterator en Java

La excepción ConcurrentModificationException ha sido lanzada por métodos que han detectado modificaciones simultáneas de un objeto cuando dicha modificación no está permitida. Si un subproceso modifica una colección directamente mientras itera sobre la colección con un iterador rápido, el iterador lanzará esta ConcurrentModificationException . Aquí comprenderemos esta excepción con un ejemplo de por qué ocurre y cómo se realizan los cambios simultáneamente, que es la causa raíz de esta excepción. En la parte posterior, entenderemos cómo arreglarlo.

Ejemplo 1: excepción de modificación simultánea

// Java Program to ConcurrentModificationException while
// using Iterator
  
// Importing ArrayList and Iterator classes from java.util
// package
import java.util.ArrayList;
import java.util.Iterator;
  
// Main class
public class GFG {
  
    // Main driver method
    public static void main(String[] args)
    {
        // Creating an object of ArrayList class
        // Declaring object of Integer type
        ArrayList<Integer> list = new ArrayList<>();
  
        // Adding custom integer elements to the object
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
  
        // Iterating over object elements using iterator
        Iterator<Integer> iterator = list.iterator();
  
        // Condition check
        // It holds true till there is single element
        // remainin in the List
        while (iterator.hasNext()) {
  
            // Rolling over to next element using next()
            // method
            Integer value = iterator.next();
  
            // Print the element value
            System.out.println("value: " + value);
  
            // If element equals certain value
            if (value.equals(2)) {
  
                // Display command for better readability
                System.out.println(
                    "========================");
  
                // Removing entered value in object
                System.out.println("removing value: "
                                   + value);
  
                // Making changes simultaneously
                System.out.println(
                    "========================");
                list.remove(value);
            }
        }
    }
}

Producción:

Salida Explicación:

La excepción ConcurrentModificationException se lanza cuando se llama al método next() cuando el iterador está iterando la lista y estamos haciendo modificaciones en ella simultáneamente. Ahora, para evitar esta excepción, analicemos una forma de usar el iterador directamente, que es la siguiente:

Ejemplo 2: Resolviendo ConcurrentModificationException

// Java Program to Avoid ConcurrentModificationException by
// directly using Iterator
  
// Importing ArrayList and Iterator classes
// from java.util package
import java.util.ArrayList;
import java.util.Iterator;
  
// Main class
public class Main {
  
    // Mai driver method
    public static void main(String[] args)
    {
        // Creating an ArrayList object of integer type
        ArrayList<Integer> list = new ArrayList<>();
  
        // Custom integer elements are added
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
  
        // Iterating directly over elements of object
        Iterator<Integer> iterator = list.iterator();
  
        // Condition check
        // It holds true till there is single element
        // remaining in the List using hasNext() method
        while (iterator.hasNext()) {
  
            // Rolling over elements using next() method
            Integer value = iterator.next();
  
            // print the values
            System.out.println("value: " + value);
  
            // If value equals certain integer element
            // entered Say it be 2
            if (value.equals(2)) {
  
                // Display command only
                System.out.println(
                    "========================");
  
                // Removing the entered value 
                System.out.println("removing value: "
                                   + value);
                 
                // Display command only
                System.out.println(
                    "========================");
                
                // Removing current value in Collection
                // using remove() method 
                iterator.remove();
            }
        }
    }
}

Producción:

Salida Explicación:

ConcurrentModificationException no se genera porque el método remove() no provoca una ConcurrentModificationException.