Remover elementos da coleção enquanto itera

AFAIK, existem duas abordagens:

1. Iterar uma cópia da coleção
2. Use o iterador da coleção real

Por exemplo,

List<Foo> fooListCopy = new ArrayList<Foo>(fooList);
for(Foo foo : fooListCopy){
    // modify actual fooList
}

e

Iterator<Foo> itr = fooList.iterator();
while(itr.hasNext()){
    // modify actual fooList using itr.remove()
}

Existem razões para preferir uma abordagem à outra (por exemplo, preferindo a primeira abordagem pelo simples motivo de legibilidade)?

Deixe-me dar alguns exemplos com algumas alternativas para evitar a ConcurrentModificationException.

Suponha que tenhamos a seguinte coleção de livros

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

Coletar e remover

A primeira técnica consiste em coletar todos os objetos que queremos excluir (por exemplo, usando um loop for aprimorado) e depois de concluir a iteração, removemos todos os 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);

Isso supõe que a operação que você deseja executar seja "excluir".

Se você deseja "adicionar", essa abordagem também funcionaria, mas eu presumiria que você iteraria sobre uma coleção diferente para determinar quais elementos você deseja adicionar a uma segunda coleção e, em seguida, emitiria um addAllmétodo no final.

Usando ListIterator

Se você estiver trabalhando com listas, outra técnica consiste em usar um ListIteratorque tenha suporte para remoção e adição de itens durante a própria iteração.

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

Novamente, usei o método "remove" no exemplo acima, que é o que sua pergunta parecia implicar, mas você também pode usar o addmétodo para adicionar novos elementos durante a iteração.

Usando JDK> = 8

Para aqueles que trabalham com o Java 8 ou versões superiores, existem algumas outras técnicas que você pode usar para tirar proveito disso.

Você pode usar o novo removeIfmétodo na Collectionclasse base:

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

Ou use a nova API de fluxo:

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

Neste último caso, para filtrar elementos de uma coleção, você reatribui a referência original à coleção filtrada (ou seja books = filtered) ou usou a coleção filtrada aos removeAllelementos encontrados da coleção original (ou seja books.removeAll(filtered)).

Usar sublista ou subconjunto

Existem outras alternativas também. Se a lista estiver classificada e você desejar remover elementos consecutivos, poderá criar uma sub-lista e desmarcá-la:

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

Como a sub-lista é apoiada pela lista original, essa seria uma maneira eficiente de remover essa sub-coleção de elementos.

Algo semelhante poderia ser alcançado com conjuntos classificados usando o NavigableSet.subSetmétodo, ou qualquer um dos métodos de corte oferecidos lá.

Considerações:

Que método usado pode depender do que você pretende fazer

• A coleta e a removeAltécnica funcionam com qualquer coleção (coleção, lista, conjunto etc.).
• A ListIteratortécnica, obviamente, só funciona com listas, desde que os seus dados ListIteratorofertas de implementação apoio para acções adicionar e remover.
• A Iteratorabordagem funcionaria com qualquer tipo de coleção, mas suporta apenas operações de remoção.
• Com a abordagem ListIterator/ Iterator, a vantagem óbvia é não ter que copiar nada, pois removemos à medida que iteramos. Então, isso é muito eficiente.
• O exemplo de fluxos do JDK 8 na verdade não removeu nada, mas procurou os elementos desejados e, em seguida, substituímos a referência de coleção original pelo novo e deixamos o antigo ser coletado como lixo. Portanto, iteramos apenas uma vez sobre a coleção e isso seria eficiente.
• Na coleta e removeAllabordagem, a desvantagem é que precisamos iterar duas vezes. Primeiro, iteramos no loop foor procurando um objeto que atenda aos nossos critérios de remoção e, uma vez encontrado, pedimos para removê-lo da coleção original, o que implicaria um segundo trabalho de iteração para procurar esse item para remova.
• Eu acho que vale a pena mencionar que o método remove da Iteratorinterface está marcado como "opcional" nos Javadocs, o que significa que pode haver Iteratorimplementações que serão lançadas UnsupportedOperationExceptionse invocarmos o método remove. Como tal, eu diria que essa abordagem é menos segura do que outras, se não podemos garantir o suporte do iterador para a remoção de elementos.

No Java 8, há outra abordagem. Coleção # removeIf

por exemplo:

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);

list.removeIf(i -> i > 2);

Existem razões para preferir uma abordagem à outra

A primeira abordagem funcionará, mas possui a sobrecarga óbvia de copiar a lista.

A segunda abordagem não funcionará porque muitos contêineres não permitem modificações durante a iteração. Isso incluiArrayList .

Se a única modificação é remover o elemento atual, você pode fazer o segundo trabalho de abordagem usando itr.remove()(ou seja, usar o iterador 's remove()método, não o recipiente ' s). Esse seria o meu método preferido para iteradores compatíveis remove().

Apenas a segunda abordagem funcionará. Você pode modificar a coleção durante a iteração usando iterator.remove()apenas. Todas as outras tentativas causarão ConcurrentModificationException.

Favorito antigo do temporizador (ainda funciona):

List<String> list;

for(int i = list.size() - 1; i >= 0; --i) 
{
        if(list.get(i).contains("bad"))
        {
                list.remove(i);
        }
}

Você não pode fazer o segundo, porque mesmo se você usar o remove()método no Iterator , receberá uma exceção .

Pessoalmente, eu preferiria o primeiro para todas as Collectioninstâncias, apesar do escutar adicional de criar o novo Collection, acho menos propenso a erros durante a edição por outros desenvolvedores. Em algumas implementações de coleção, o Iterator remove()é suportado; em outros, não. Você pode ler mais nos documentos do Iterator .

A terceira alternativa é criar uma nova Collectioniteração sobre o original e adicionar todos os membros do primeiro Collectionao segundo Collectionque não estão prontos para exclusão. Dependendo do tamanho Collectione do número de exclusões, isso pode economizar significativamente na memória, quando comparado à primeira abordagem.

Eu escolheria o segundo, pois você não precisa fazer uma cópia da memória e o Iterator funciona mais rápido. Então você economiza memória e tempo.

por que não isso?

for( int i = 0; i < Foo.size(); i++ )
{
   if( Foo.get(i).equals( some test ) )
   {
      Foo.remove(i);
   }
}

E se for um mapa, não uma lista, você pode usar keyset ()