removeAll 似乎影响了它的论点

Question

我编写了一个通用的 Partition 类（分区是将集合划分为不相交的子集，称为部分）。在内部这是一个Map<T,Integer> 和一个Map<Integer,Set<T>>，其中整数是部件的标签。例如partition.getLabel(T t) 给出了 t 所在部分的标签，partition.move(T t, Integer label) 将 t 移动到由标签标记的分区（在内部，它更新了两个 Maps）。

但是我将对象集合移动到新部分的方法不起作用。似乎 Set.removeAll() 正在影响它的论点。我认为问题类似于 ConcurrentModificationException，但我无法解决。抱歉，代码比较长，但我已经标记了问题所在（大约一半），底部的输出应该清楚问题是什么 - 最后分区处于非法状态。

    import java.util.*;

    public class Partition<T> {
  private Map<T,Integer> objToLabel = new HashMap<T,Integer>();
     private Map<Integer,Set<T>> labelToObjs = 
       new HashMap<Integer,Set<T>>();
     private List<Integer> unusedLabels;
     private int size;  // = number of elements

     public Partition(Collection<T> objects) {
      size = objects.size();
      unusedLabels = new ArrayList<Integer>();
      for (int i = 1; i < size; i++)
       unusedLabels.add(i);
      // Put all the objects in part 0. 
      Set<T> part = new HashSet<T>(objects);
      for (T t : objects)
       objToLabel.put(t,0);
      labelToObjs.put(0,part);
     }

     public Integer getLabel(T t) {
      return objToLabel.get(t);
     }
     public Set<T> getPart(Integer label) {
      return labelToObjs.get(label);
     }
     public Set<T> getPart(T t) {
      return getPart(getLabel(t));
     }

     public Integer newPart(T t) { 
      // Move t to a new part. 
      Integer newLabel = unusedLabels.remove(0); 
      labelToObjs.put(newLabel,new HashSet<T>()); 
      move(t, newLabel); 
      return newLabel; 
     } 
     public Integer newPart(Collection<T> things) {
      // Move things to a new part. (This assumes that 
      // they are all in the same part to start with.)
      Integer newLabel = unusedLabels.remove(0);
      labelToObjs.put(newLabel,new HashSet<T>());
      moveAll(things, newLabel); 
      return newLabel; 
     }
     public void move(T t, Integer label) {
      // Move t to the part "label". 
      Integer oldLabel = getLabel(t);
      getPart(oldLabel).remove(t);
      if (getPart(oldLabel).isEmpty())  // if the old part is 
       labelToObjs.remove(oldLabel);  // empty, remove it
      getPart(label).add(t);
      objToLabel.put(t,label);
     }
     public void moveAll(Collection<T> things, Integer label) {
      // Move all the things from their current part to label. 
      // (This assumes all the things are in the same part.)
      if (things.size()==0)  return;

      T arbitraryThing = new ArrayList<T>(things).get(0);
      Set<T> oldPart = getPart(arbitraryThing);

   // THIS IS WHERE IT SEEMS TO GO WRONG //////////////////////////
      System.out.println(" oldPart = " + oldPart);
      System.out.println(" things = " + things);
      System.out.println("Now doing oldPart.removeAll(things) ...");
      oldPart.removeAll(things);
      System.out.println(" oldPart = " + oldPart);
      System.out.println(" things = " + things);

      if (oldPart.isEmpty())
       labelToObjs.remove(objToLabel.get(arbitraryThing));

      for (T t : things)
       objToLabel.put(t,label);
      getPart(label).addAll(things);
     }

     public String toString() {
      StringBuilder result = new StringBuilder();
      result.append("\nPARTITION OF " + size + " ELEMENTS INTO " + 
        labelToObjs.size() + " PART");
      result.append((labelToObjs.size()==1 ? "" : "S") + "\n");
      for (Map.Entry<Integer,Set<T>> mapEntry : 
        labelToObjs.entrySet()) {
       result.append("PART " + mapEntry.getKey() + ": ");
       result.append(mapEntry.getValue() + "\n");
      }
      return result.toString();
     }

     public static void main(String[] args) {
      List<String> strings = 
        Arrays.asList("zero one two three".split(" "));

      Partition<String> p = new Partition<String>(strings);
      p.newPart(strings.get(3));  // move "three" to a new part
      System.out.println(p);

      System.out.println("Now moving all of three's part to the " + 
        "same part as zero.\n");
      Collection<String> oldPart = p.getPart(strings.get(3));
      //oldPart = Arrays.asList(new String[]{"three"});  // works fine!
      p.moveAll(oldPart, p.getLabel(strings.get(0)));
      System.out.println(p);
     }
    }

/* OUTPUT
PARTITION OF 4 ELEMENTS INTO 2 PARTS
PART 0: [two, one, zero]
PART 1: [three]

Now moving all of three's part to the same part as zero.

 oldPart = [three]
 things = [three]
Now doing oldPart.removeAll(things) ...
 oldPart = []
 things = []

PARTITION OF 4 ELEMENTS INTO 1 PART
PART 0: [two, one, zero]
*/

Answer 1

使用我的调试器，我在 removeAll 之前放置了一个断点，我可以看到（正如我所怀疑的那样）oldPart 和事物是同一个集合，因此删除所有元素会清除该集合。

Answer 2

您的代码非常混乱，但据我所知，oldPart 和 things 实际上是同一个对象。 Set.removeAll() 当然不会影响它的参数，除非它与调用它的对象相同：

public boolean removeAll(Collection<?> c) {
    boolean modified = false;

    if (size() > c.size()) {
        for (Iterator<?> i = c.iterator(); i.hasNext(); )
            modified |= remove(i.next());
    } else {
        for (Iterator<?> i = iterator(); i.hasNext(); ) {
            if (c.contains(i.next())) {
                i.remove();
                modified = true;
            }
        }
    }
    return modified;
}

更新：

消除这种情况的简单方法是在moveAll() 方法中使用things 的副本。事实上，这样的副本已经存在。

T arbitraryThing = new ArrayList<T>(things).get(0);

此行创建但随后立即丢弃things 的副本。所以我建议将其替换为：

ArrayList<T> thingsToRemove = new ArrayList<T>(things)
T arbitraryThing = thingsToRemove.get(0);

并且在该方法的其余部分中，将对things 的所有引用替换为thingsToRemove。