在迭代它时从java中的集合中删除项目

Question

我希望能够在迭代它时从一个集合中删除多个元素。 最初我希望迭代器足够智能，以便下面的天真解决方案能够工作。

Set<SomeClass> set = new HashSet<SomeClass>();
fillSet(set);
Iterator<SomeClass> it = set.iterator();
while (it.hasNext()) {
    set.removeAll(setOfElementsToRemove(it.next()));
}

但是这会引发ConcurrentModificationException 。

请注意，iterator.remove（）将无法正常工作，因为我需要一次删除多个东西。 还假设无法识别“动态”删除哪些元素，但可以编写方法setOfElementsToRemove() 。 在我的特定情况下，它将占用大量内存和处理时间来确定迭代时要删除的内容。 由于内存限制，也无法进行复制。

setOfElementsToRemove()将生成一些我想要删除的SomeClass实例集， fillSet(set)将使用条目填充集合。

在搜索Stack Overflow之后，我找不到一个很好的解决方案来解决这个问题，但是几个小时后我才意识到以下情况可以解决这个问题。

Set<SomeClass> set = new HashSet<SomeClass>();
Set<SomeClass> outputSet = new HashSet<SomeClass>();
fillSet(set);
while (!set.isEmpty()) {
    Iterator<SomeClass> it = set.iterator();
    SomeClass instance = it.next();
    outputSet.add(instance);
    set.removeAll(setOfElementsToRemoveIncludingThePassedValue(instance));
}

setOfElementsToRemoveIncludingThePassedValue()将生成一组要删除的元素，包括传递给它的值。 我们需要删除传递的值，因此set将为空。

我的问题是，是否有人有更好的方法这样做，或者是否有支持这种删除的收集操作。

此外，我想我会发布我的解决方案，因为似乎有需要，我想贡献Stack Overflow的优秀资源。

Answer 1

通常，当您在循环集合时从集合中删除元素时，您将获得并发修改异常 。 这部分是Iterator接口具有remove（）方法的部分原因。 使用迭代器是在遍历它们时修改元素集合的唯一安全方法。

代码将是这样的：

Set<SomeClass> set = new HashSet<SomeClass>();
fillSet(set);
Iterator<SomeClass> setIterator = set.iterator();
while (setIterator.hasNext()) {
    SomeClass currentElement = setIterator.next();
    if (setOfElementsToRemove(currentElement).size() > 0) {
        setIterator.remove();
    }
}

这样您就可以安全地从setOfElementsToRemove（）中删除所有生成删除集的元素。

编辑

基于对另一个答案的评论，这可能更符合您的要求：

Set<SomeClass> set = new HashSet<SomeClass>();
Set<SomeClass> removalSet = new HashSet<SomeClass>();
fillSet(set);

for (SomeClass currentElement : set) {
    removalSet.addAll(setOfElementsToRemove(currentElement);
}

set.removeAll(removalSet);

Answer 2

您可以实际使用Google集合（而不是您自己无法做到的事情）而不是遍历集合中的所有元素来删除所需的元素，并应用谓词来掩盖您不需要的集合。 。

package com.stackoverflow.q1675037;

import java.util.HashSet;
import java.util.Set;

import org.junit.Assert;
import org.junit.Test;

import com.google.common.base.Predicate;
import com.google.common.collect.Iterables;
import com.google.common.collect.Sets;


public class SetTest
{
public void testFilter(final Set<String> original, final Set<String> toRemove, final Set<String> expected)
{

    Iterable<String> mask = Iterables.filter(original, new Predicate<String>()
    {
        @Override
        public boolean apply(String next) {
        return !toRemove.contains(next);
        }
    });

    HashSet<String> filtered = Sets.newHashSet(mask);

    Assert.assertEquals(original.size() - toRemove.size(), filtered.size());
    Assert.assertEquals(expected, filtered);        
}


@Test
public void testFilterNone()
{
    Set<String> original = new HashSet<String>(){
        {
            this.add("foo");
            this.add("bar");
            this.add("foobar");
        }
    };

    Set<String> toRemove = new HashSet();

    Set<String> expected = new HashSet<String>(){
        {
            this.add("foo");                
            this.add("bar");
            this.add("foobar");
        }
    };

    this.testFilter(original, toRemove, expected);
}

@Test
public void testFilterAll()
{
    Set<String> original = new HashSet<String>(){
        {
            this.add("foo");
            this.add("bar");
            this.add("foobar");
        }
    };

    Set<String> toRemove = new HashSet<String>(){
        {
            this.add("foo");
            this.add("bar");
            this.add("foobar");
        }
    };

    HashSet<String> expected = new HashSet<String>();
    this.testFilter(original, toRemove, expected);
}    

@Test
public void testFilterOne()
{
    Set<String> original = new HashSet<String>(){
        {
            this.add("foo");
            this.add("bar");
            this.add("foobar");
        }
    };

    Set<String> toRemove = new HashSet<String>(){
        {
            this.add("foo");
        }
    };

    Set<String> expected = new HashSet<String>(){
        {
            this.add("bar");
            this.add("foobar");
        }
    };

    this.testFilter(original, toRemove, expected);
}    


@Test
public void testFilterSome()
{
    Set<String> original = new HashSet<String>(){
        {
            this.add("foo");
            this.add("bar");
            this.add("foobar");
        }
    };

   Set<String> toRemove = new HashSet<String>(){
        {
            this.add("bar");
            this.add("foobar");
        }
    };

    Set<String> expected = new HashSet<String>(){
        {
            this.add("foo");
        }
    };

    this.testFilter(original, toRemove, expected);
}    
}

Answer 3

任何涉及从迭代中删除的集合中进行迭代但不通过迭代器的解决方案绝对不会起作用。 除了可能的一个：你可以使用Collections.newSetFromMap(new ConcurrentHashMap<SomeClass, Boolean>( sizing params )) 。 问题是，现在你的迭代器只是微弱的一致 ，这意味着每次你删除一个你还没有遇到过的元素时，这个元素是否会在你的迭代中显示出来是未定义的。 如果这不是问题，这可能对你有用。

您可以做的另一件事是建立一个toRemove集合，然后set.removeAll(itemsToRemove); 只在最后。 或者，在开始之前复制该集，这样您可以在从另一个副本移除时迭代一个副本。

编辑：哎呀，我看到toRemove已经建议了toRemove想法（虽然有一个不必要的手动toRemove removeAll ）。

Answer 4

您可以尝试java.util.concurrent.CopyOnWriteArraySet ，它为您提供一个迭代器，它是迭代器创建时集的快照。 您对该集所做的任何更改（即通过调用removeAll() ）将在迭代器中不可见，但如果您查看该集本身（并且removeAll()将不会抛出）则可见。

Answer 5

有一个简单的答案 - 使用Iterator.remove（）方法。

Answer 6

如果你有一个副本的足够的内存，我会假设你有足够的内存两个副本。 您引用的Kafka-esque规则似乎并不禁止:)

我的建议是：

fillSet(set);
fillSet(copy);
for (Object item : copy) {
   if (set.contains(item)) { // ignore if not
     set.removeAll(setOfStuffToRemove())
   }
}

所以复制保持不变，只是提供循环的东西，而设置遭受删除。 在此期间从集合中删除的东西将被忽略。

Answer 7

为什么不在要删除的对象上使用迭代器的remove方法 ？

引入迭代器主要是因为枚举器在枚举时无法处理删除。

Answer 8

你应该调用Iterator.remove方法。

另请注意，在大多数java.util集合中，如果集合的内容已更改，则remove方法将生成异常。 因此，如果代码是多线程的，请格外小心，或使用并发集合。

Answer 9

可以实现一个Set ，允许在迭代它时删除它的元素。

我认为标准实现（HashSet，TreeSet等）不允许它，因为这意味着它们可以使用更高效的算法，但这并不难。

以下是使用Google Collections的不完整示例：

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import com.google.common.base.Predicates;
import com.google.common.collect.ForwardingSet;
import com.google.common.collect.Iterators;
import com.google.common.collect.Sets;

public class ConcurrentlyModifiableSet<E>
extends ForwardingSet<E> {
 /** Create a new, empty set */
 public ConcurrentlyModifiableSet() {
  Map<E, Boolean> map = new ConcurrentHashMap<E, Boolean>();
  delegate = Sets.newSetFromMap(map);
 }

 @Override
 public Iterator<E> iterator() {
  return Iterators.filter(delegate.iterator(), Predicates.in(delegate));
 }

 @Override
 protected Set<E> delegate() {
  return this.delegate;
 }

 private Set<E> delegate;
}

注意：迭代器不支持remove()操作（但问题中的示例不需要它。）

Answer 10

从Java API复制：

List接口提供了一个特殊的迭代器，称为ListIterator， 它允许元素插入和替换，以及Iterator接口提供的常规操作之外的双向访问。 提供了一种方法来获得从列表中的指定位置开始的列表迭代器。

我想我会指出ListIterator是一种特殊的Iterator，它是为了替换而构建的。