Удалить элементы из коллекции во время итерации

AFAIK, есть два подхода:

1. Перебрать копию коллекции
2. Используйте итератор фактической коллекции

Например,

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

и

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

Есть ли причины предпочитать один подход другому (например, предпочтение первого подхода по простой причине читабельности)?

Позвольте мне привести несколько примеров с некоторыми альтернативами, чтобы избежать ConcurrentModificationException.

Предположим, у нас есть следующая коллекция книг

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

Собрать и удалить

Первый метод состоит в том, чтобы собрать все объекты, которые мы хотим удалить (например, используя расширенный цикл for), и после того, как мы закончим итерацию, мы удалим все найденные объекты.

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

Это предполагает, что операция, которую вы хотите сделать, это «удалить».

Если вы хотите «добавить» этот подход, он также будет работать, но я предполагаю, что вы переберите другую коллекцию, чтобы определить, какие элементы вы хотите добавить во вторую коллекцию, а затем выпустите addAllметод в конце.

Использование ListIterator

Если вы работаете со списками, другой метод заключается в использовании ListIteratorэлемента, который поддерживает удаление и добавление элементов во время самой итерации.

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

Опять же, я использовал метод «удалить» в приведенном выше примере, что, по-видимому, подразумевает ваш вопрос, но вы также можете использовать его addметод для добавления новых элементов во время итерации.

Используя JDK> = 8

Для тех, кто работает с Java 8 или более поздними версиями, есть несколько других методов, которые вы можете использовать, чтобы воспользоваться этим.

Вы можете использовать новый removeIfметод в Collectionбазовом классе:

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

Или используйте новый потоковый API:

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

В последнем случае, чтобы отфильтровать элементы из коллекции, вы переназначаете исходную ссылку на отфильтрованную коллекцию (т. Е. books = filtered) Или используете отфильтрованную коллекцию removeAllнайденным элементам из исходной коллекции (т books.removeAll(filtered). Е. ).

Использовать подсписок или подмножество

Есть и другие альтернативы. Если список отсортирован, и вы хотите удалить последовательные элементы, вы можете создать подсписок, а затем очистить его:

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

Поскольку подсписок поддерживается исходным списком, это будет эффективным способом удаления этого подколлекции элементов.

Нечто подобное может быть достигнуто с помощью сортированных наборов с использованием NavigableSet.subSetметода или любого из предложенных там методов нарезки.

Соображения:

Какой метод вы используете, может зависеть от того, что вы собираетесь делать

• Коллекционирование и removeAlтехника работают с любой коллекцией (Коллекция, Список, Набор и т. Д.).
• ListIteratorМетод работает , очевидно , только со списками, при условии , что их данные ListIteratorпредложения по реализации поддержки для добавления и удаления операций.
• IteratorПодход будет работать с любым типом коллекции, но он поддерживает только операцию УДАЛИТЬ.
• При использовании ListIterator/ Iteratorподхода очевидным преимуществом является отсутствие необходимости что-либо копировать, поскольку мы удаляем по мере итерации. Итак, это очень эффективно.
• Пример потоков JDK 8 на самом деле ничего не удалял, но искал нужные элементы, а затем мы заменили исходную ссылку на коллекцию новой и позволили старой собирать мусор. Итак, мы перебираем коллекцию только один раз, и это будет эффективно.
• В Собирать и removeAllподойти недостаток в том , что мы должны итерация дважды. Сначала мы выполняем итерацию в цикле foor, ища объект, который соответствует нашим критериям удаления, и как только мы его найдем, мы просим удалить его из исходной коллекции, что подразумевает вторую итерационную работу для поиска этого элемента, чтобы убери это.
• Я думаю, что стоит упомянуть, что метод удаления Iteratorинтерфейса помечен как «необязательный» в Javadocs, что означает, что могут быть Iteratorреализации, которые выдают, UnsupportedOperationExceptionесли мы вызываем метод удаления. Таким образом, я бы сказал, что этот подход менее безопасен, чем другие, если мы не можем гарантировать поддержку итератора для удаления элементов.

В Java 8 есть другой подход. Коллекция # removeIf

например:

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

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

Есть ли причины предпочитать один подход другому?

Первый подход будет работать, но имеет очевидные накладные расходы при копировании списка.

Второй подход не будет работать, потому что многие контейнеры не допускают изменения во время итерации. Это включает в себяArrayList .

Если единственной модификацией является удаление текущего элемента, вы можете заставить работать второй подход с помощью itr.remove()(то есть использовать метод итератора , а remove()не контейнера ). Это был бы мой предпочтительный метод для итераторов, которые поддерживают remove().

Только второй подход будет работать. Вы можете изменить коллекцию во время итерации, используя iterator.remove()только. Все остальные попытки вызовут ConcurrentModificationException.

Фаворит Старого Таймера (он все еще работает):

List<String> list;

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

Преимущества:

1. Перебирает список только один раз
2. Никаких дополнительных объектов не создано, или другой ненужной сложности
3. Нет проблем с попыткой использовать индекс удаленного элемента, потому что ... ну, подумайте об этом!

Вы не можете сделать второе, потому что даже если вы используете remove()метод Iterator , вы получите исключение .

Лично я предпочел бы первый для всех Collectionслучаев, несмотря на то, что при создании нового Collectionя случайно услышал , что он менее подвержен ошибкам при редактировании другими разработчиками. В некоторых реализациях Collection поддерживается Iterator remove(), в других - нет. Вы можете прочитать больше в документации по Iterator .

Третий вариант - создать новый Collection, выполнить итерацию по оригиналу и добавить все элементы первого, Collectionвторого Collection, которые не подлежат удалению. В зависимости от размера Collectionи количества удалений это может значительно сэкономить память по сравнению с первым подходом.

Я бы выбрал второе, так как вам не нужно делать копию памяти, и итератор работает быстрее. Таким образом, вы экономите память и время.

почему не это?

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

И если это карта, а не список, вы можете использовать keyset ()