Eliminar elementos de la colección mientras se itera

Permítanme dar algunos ejemplos con algunas alternativas para evitar un ConcurrentModificationException.

Supongamos que tenemos la siguiente colección de libros

List<Book> books = new ArrayList<Book>();
books.add(new Book(new ISBN("0-201-63361-2")));
books.add(new Book(new ISBN("0-201-63361-3")));
books.add(new Book(new ISBN("0-201-63361-4")));

Recoger y Retirar

La primera técnica consiste en recopilar todos los objetos que queremos eliminar (por ejemplo, usando un bucle for mejorado) y después de terminar de iterar, eliminamos todos los objetos encontrados.

ISBN isbn = new ISBN("0-201-63361-2");
List<Book> found = new ArrayList<Book>();
for(Book book : books){
    if(book.getIsbn().equals(isbn)){
        found.add(book);
    }
}
books.removeAll(found);

Esto supone que la operación que desea hacer es "eliminar".

Si quieres " añadir" este enfoque también funcionaría, pero asumiría que iteraría sobre una colección diferente para determinar qué elementos desea agregar a una segunda colección y luego emitiría un método addAll al final.

Usando ListIterator

Si está trabajando con listas, otra técnica consiste en usar un ListIterator que tiene soporte para la eliminación y adición de elementos durante la iteración en sí.

ListIterator<Book> iter = books.listIterator();
while(iter.hasNext()){
    if(iter.next().getIsbn().equals(isbn)){
        iter.remove();
    }
}

Nuevamente, usé el método" remove " en el ejemplo anterior que es lo que su pregunta parecía implicar, pero también puede usar su método add para agregar nuevos elementos durante la iteración.

Usando JDK 8

Para aquellos que trabajan con Java 8 o versiones superiores, hay un par de otras técnicas que podría utilizar para tomar ventaja de ella.

Puedes usar el nuevo método removeIf en la clase base Collection:

ISBN other = new ISBN("0-201-63361-2");
books.removeIf(b -> b.getIsbn().equals(other));

O use la nueva API de stream:

ISBN other = new ISBN("0-201-63361-2");
List<Book> filtered = books.stream()
                           .filter(b -> b.getIsbn().equals(other))
                           .collect(Collectors.toList());

En este último caso, para filtrar elementos de una colección, reasigne la referencia original a la colección filtrada (es decir, books = filtered) o utilice la colección filtrada a removeAll los elementos encontrados de la colección original (es decir, books.removeAll(filtered)).

Use Sublista o Subconjunto

También hay otras alternativas. Si la lista está ordenada y desea eliminar elementos consecutivos, puede crear una sublista y luego borrarla:

books.subList(0,5).clear();

Dado que la sublista está respaldada por la lista original, esto sería una forma eficiente de eliminando esta subcolección de elementos.

Algo similar podría lograrse con conjuntos ordenados usando el método NavigableSet.subSet, o cualquiera de los métodos de corte ofrecidos allí.

Consideraciones:

El método que utilice puede depender de lo que tenga la intención de hacer

• La técnica collect y removeAl funciona con cualquier Colección (Colección, Lista, Conjunto, etc.).
• La técnica ListIterator obviamente solo funciona con listas, siempre que su dado ListIterator la implementación ofrece soporte para agregar y quitar operaciones.
• El enfoque Iterator funcionaría con cualquier tipo de colección, pero solo admite operaciones de eliminación.
• Con el ListIterator/Iterator enfoque la ventaja obvia es no tener que copiar nada, ya que eliminamos a medida que iteramos. Por lo tanto, esto es muy eficiente.
• El ejemplo de flujos JDK 8 no elimina nada, sino que busca los elementos deseados, y luego reemplazamos la referencia de la colección original con la nueva, y que la vieja sea recogida de basura. Por lo tanto, iteramos solo una vez sobre la colección y eso sería eficiente.
• En el enfoque collect y removeAll la desventaja es que tenemos que iterar dos veces. Primero iteramos en el foor-loop buscando un objeto que coincida con nuestros criterios de eliminación, y una vez que lo hayamos encontrado, pedimos eliminarlo de la colección original, lo que implicaría un segundo trabajo de iteración para buscar este elemento con el fin de eliminarlo.
• I creo que vale la pena mencionar que el método remove de la interfaz Iterator está marcado como "opcional" en Javadocs, lo que significa que podría haber Iterator implementaciones que arrojen UnsupportedOperationException si invocamos el método remove. Como tal, diría que este enfoque es menos seguro que otros si no podemos garantizar el soporte del iterador para la eliminación de elementos.