Método remove() del iterador de Java

1. Introducción al método remove() de Colección
2. Utilice el método remove() de Colección
3. Introducción al método remove() de Iterator
4. Utilice el método remove() del Iterador

Los desarrolladores de Java a menudo necesitan eliminar el elemento u objeto de ArrayList mientras iteran.

Aquí, el problema surge cuando intentan eliminar el objeto de la colección original mientras lo recorren mientras arroja la ConcurrentModificationException. En este artículo, aprenderemos cómo el método remove() del Iterator y el método remove() de la Colección funcionan de manera diferente.

Introducción al método remove() de Colección

En Java, Colección es una interfaz que contiene diferentes tipos de datos como ArrayList, Set, etc. Para eliminar un elemento de la Colección, podemos usar el método remove() tomando la colección como una referencia.

Los usuarios pueden seguir la siguiente sintaxis para usar el método remove() con la colección.

collection.remove(Ind);

Ind: el método remove() elimina elementos del índice Ind de la colección referenciada.

Utilice el método remove() de Colección

En el siguiente ejemplo, hemos creado la colección y eliminado el elemento del segundo y cuarto índice usando el método remove() de la colección.

import java.util.ArrayList;
class Test {
  public static void main(String[] args) {
    // Create an ArrayList
    ArrayList<String> testList = new ArrayList<String>();
    // Add elements in the ArrayList
    testList.add("Apple");
    testList.add("Banana");
    testList.add("Cat");
    testList.add("Dog");
    testList.add("Fox");
    testList.add("Cow");
    // Removing the element at index 2 and 4
    System.out.println(testList.remove(2) + " removed\n");
    System.out.println(testList.remove(4) + " removed");
  }
}

Producción :

Cat removed
Cow removed

En el resultado anterior, los usuarios pueden ver que una vez que eliminamos el “gato” del segundo índice, todos los elementos en ArrayList se desplazan en un índice.

Cuando tratamos de eliminar el elemento del 4.° índice después de eliminar el elemento del 2.° índice, el método remove() elimina el elemento del 5.° índice de la ArrayList real, ya que todos los elementos después del 2.° índice cambiaron al dejado por 1.

Hemos aprendido cómo funciona normalmente el método remove() de Collection.

Introducción al método remove() de Iterator

Ahora, la pregunta es, ¿cuál es la diferencia entre los métodos remove() de Iterator y Collection, ya que ambos eliminan el elemento de la Colección?

Entendamos el problema usando el siguiente código.

import java.util.ArrayList;
class Test {
  public static void main(String[] args) {
    // Create an ArrayList
    ArrayList<String> testList = new ArrayList<String>();
    // Add elements in the ArrayList
    testList.add("Apple");
    testList.add("Banana");
    testList.add("Cat");
    testList.add("Dog");
    testList.add("Fox");
    testList.add("Cow");
    for (String element : testList) {
      if (element.equals("Cat")) {
        testList.remove(element);
      }
    }
  }
}

En el ejemplo anterior, hemos creado el ArrayList de diferentes cadenas. Estamos iterando a través de ArrayList usando el bucle for y comprobando que si el elemento es igual a cat, intentamos eliminarlo usando el método collection.remove().

En el resultado, los usuarios pueden ver que arroja la excepción ConcurrentModificationException cuando modificamos la lista original mientras la iteramos.

Producción :

Exception in thread "main" java.util.ConcurrentModificationException

Para resolver nuestro problema, podemos usar el iterador para iterar a través de ArrayList y el método remove() del Iterator para eliminar el elemento.

Utilice el método remove() del Iterador

En el siguiente ejemplo, hemos creado el nombre del iterador itr para la Lista de matrices de la cadena. Estamos iterando a través de ArrayList usando el bucle for y itr.

Además, estamos eliminando el elemento Fox de ArrayList mientras iteramos a través de él.

import java.util.ArrayList;
import java.util.Iterator;

class Test {
  public static void main(String[] args) {
    // Create an ArrayList
    ArrayList<String> testList = new ArrayList<String>();
    // Add elements in the ArrayList
    testList.add("Apple");
    testList.add("Banana");
    testList.add("Cat");
    testList.add("Dog");
    testList.add("Fox");
    testList.add("Cow");
    // Removing the "Fox" while iterating through the `testList`
    Iterator<String> itr = testList.iterator();
    while (itr.hasNext()) {
      String element = itr.next();
      if (element.equals("Fox")) {
        testList.remove(element);
      }
    }
    System.out.println(testList);
  }
}

Producción :

[Apple, Banana, Cat, Dog, Cow]

Podemos observar que Fox se elimina al iterar a través de ArrayList en la salida anterior.

Comprender el código del método remove() de Iterator

Hemos tomado el siguiente pseudocódigo del método remove() del iterador de los documentos oficiales de Java. Los usuarios pueden ver que también usa el método remove() de ArrayList, pero también actualiza el expectedModCount, que no lanza la excepción ConcurrentModificationException.

Siempre es necesario conocer el siguiente elemento cuando iteramos a través de ArrayList. Entonces, si tratamos de modificar la lista original usando el método remove(), no actualizará el siguiente índice y arrojará el error, y ese problema se soluciona en el método remove() del iterador.

try {
  ArrayList.this.remove(lastRet);
  cursor = lastRet;
  lastRet = -1;
  expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
  throw new ConcurrentModificationException();
}

Además, los usuarios pueden clonar la lista e iterar a través de la nueva lista. Mientras recorren la nueva lista, pueden eliminar el elemento de la lista original.