任何涉及在迭代过程中从正在迭代的集合中移除的解决方案（而不是通过迭代器）都绝对不起作用。可能除了一个：你可以用一个 Collections.newSetFromMap(new ConcurrentHashMap<SomeClass, Boolean>(sizing params)) . 问题是现在你的迭代器只是弱一致的，这意味着每次你删除一个你还没有遇到的元素时，这个元素是否会在你的迭代中出现是不确定的。如果这不是问题，这可能对你有用。
你可以做的另一件事是建立一个 toRemove 那就随你去吧 set.removeAll(itemsToRemove); 只有在最后。或者，在开始之前复制集合，这样就可以迭代一个副本，同时从另一个副本中删除。
编辑：哎呀，我知道彼得尼克斯已经建议 toRemove 想法（尽管有一个不必要的手卷 removeAll ).

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

你可以使用googlecollections（不是你自己做不到的）并应用一个 predicate 来屏蔽你不需要的元素，而不是遍历集合中的所有元素来删除你想要的元素。

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

如果你有足够的内存来存储一个副本，我假设你也有足够的内存来存储两个副本。你引用的Kafka式的规则似乎并不禁止：）
那么，我的建议是：

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

所以copy保持不变，只提供循环的内容，而set会被删除。在此期间从集合中删除的内容将被忽略。

为什么不对要删除的对象使用迭代器的remove方法呢？
迭代器的引入主要是因为枚举器在枚举时不能处理删除操作。

有可能实现 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() 操作（但问题中的示例不需要它。）

你应该打电话 Iterator.remove 方法。
另请注意，在大多数情况下 java.util 收藏 remove 方法将在集合的内容发生更改时生成异常。因此，如果代码是多线程的，请格外小心，或者使用并发集合。

通常，当在集合上循环时从集合中移除元素时，会出现并发修改异常。这就是迭代器接口具有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);

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

从java api复制：
list接口提供了一个特殊的迭代器，称为listierator，除了迭代器接口提供的正常操作之外，它还允许元素插入和替换以及双向访问。提供了一种获取从列表中指定位置开始的列表迭代器的方法。
我想我应该指出listiterator是一种特殊的迭代器，它是为替换而构建的。