对java集合的每次删除和添加执行操作

我找不到有关此的任何信息：

通常我有一个扩展哈希集的类。插入到此集合中的每个对象都有其“所有者”，我想分别统计属于每个所有者的对象数。因此，我编写了以下代码：

public class Viruses extends HashSet<Virus> {
    private HashMap<RaceName, Integer> countsPerRace = new HashMap<RaceName, Integer>();

    @Override
    public boolean add(Virus virus) {
        if(super.add(virus)) {
            RaceName race = virus.getOwner().getRace().getName();
            if(countsPerRace.containsKey(race)) {
                countsPerRace.put(race, countsPerRace.get(race) + 1);
            } else {
                countsPerRace.put(race, 1);
            }
            return true;
        } else {
            return false;
        }
    }

    @Override
    public boolean remove(Object virus) {
        if(super.remove(virus)) {
            RaceName race = ((Virus)virus).getOwner().getRace().getName();
            if(countsPerRace.containsKey(race)) {
                countsPerRace.put(race, countsPerRace.get(race) - 1);
            } else {
                throw new Exception("This should not happen...");
            }
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns number of viruses of given race.
     * @param raceId raceName of the viruses, which is equivalent of an owner id as there should never be two owners with the same race
     * @return number of viruses of given race.
     */
    public int getCount(RaceName raceId) {
        return countsPerRace.containsKey(raceId) ? countsPerRace.get(raceId) : 0;
    }

    // I don't need these, so I thought the best idea will be just to throw an exception here.
    @Override
    public boolean removeAll(Collection<?> collection) {
        throw new EngineRuntimeException("Unsupported operation!");
    }

    @Override
    public boolean addAll(Collection<? extends Virus> collection) {
        throw new EngineRuntimeException("Unsupported operation!");
    }
}

公共类病毒扩展HashSet{
private HashMap countsPerRace=new HashMap（）；
@凌驾
公共布尔添加（病毒）{
如果（超级添加（病毒））{
RaceName race=virus.getOwner（）.getRace（）.getName（）；
if（countsPerRace.containsKey（种族））{
countsPerRace.put（种族，countsPerRace.get（种族）+1）；
}否则{
countsPerRace.put（种族，1）；
}
返回true；
}否则{
返回false；
}
}
@凌驾
公共布尔删除（对象病毒）{
如果（超级删除（病毒））{
RaceName race=（（病毒）病毒）.getOwner（）.getRace（）.getName（）；
if（countsPerRace.containsKey（种族））{
countsPerRace.put（种族，countsPerRace.get（种族）-1）；
}否则{
抛出新异常（“这不应该发生…”）；
}
返回true；
}否则{
返回false；
}
}
/**
*返回给定种族的病毒数。
*@param raceId病毒的raceName，它相当于所有者id，因为不应该有两个所有者具有相同的种族
*@返回给定种族的病毒数。
*/
public int getCount（RaceName raceId）{
return countsPerRace.containsKey（raceId）？countsPerRace.get（raceId）：0；
}
//我不需要这些，所以我认为最好的办法就是在这里抛出一个例外。
@凌驾
公共布尔removeAll（集合）{
抛出新的EngineRuntimeException（“不支持的操作！”）；
}
@凌驾
public boolean addAll（Collection正如您所发现的，迭代器不能保证使用public
remove
方法

<>我强烈鼓励你在这种情况下考虑使用构图而不是继承。

但是，如果要继续使用继承解决方案，必须执行以下操作：

@Override
public Iterator<Virus> iterator() {
    final Iterator<Virus> delegate = super.iterator();
    return new Iterator<Virus>() {
        @Override
        public boolean hasNext() {
            return delegate.hasNext();
        }
        @Override
        public void remove() {
            // put your custom remove logic here
            //  ...
            delegate.remove();
        }
        @Override
        public Virus next() {
            return delegate.next();
        }
    };
}

@覆盖
公共迭代器迭代器（）{
final Iterator delegate=super.Iterator（）；
返回新的迭代器（）{
@凌驾
公共布尔hasNext（）{
返回delegate.hasNext（）；
}
@凌驾
公共空间删除（）{
//将您的自定义删除逻辑放在这里
//  ...
delegate.remove（）；
}
@凌驾
公共病毒next（）{
返回delegate.next（）；
}
};
}
使用合成

创建一个类并实现iterable。该类将包装一个哈希集并公开add和remove方法。可以使用与iterable remove相同的remove方法。
在您的情况下，使用组合而不是继承可能更容易。感谢您的建议。我决定使用组合并实现集合。