Java 多集：添加、删除和等于的问题

我的MultiSet类的一些方法有一些问题。 这是一个测试程序，如果工作正常，MultiSet类应该得到输出：“success！”。 这是测试仪：

public class MultiSetTest {

    public static void main(String[] args) {
    MultiSet<String> a = new MultiSet<String>();
    MultiSet<String> b = new MultiSet<String>();

    a.add("Foo");
    a.add("Bar");
    a.add("Foo");
    System.out.println("a:" + a); // test toString

    b.add("Bar");
    b.add("Foo");
    b.add("Bar");
    b.add("Foo");
    System.out.println("b:" + b);

    assert !a.equals(b) : "Failed test 1!"; // test equals
    assert b.remove("Bar") : "Failed test 2!"; // test remove
    assert a.equals(b) : "Failed test 3!";
    for(String s : a) { // test iterator
        assert b.remove(s) : "Failed test 4!";
    }
    assert b.size() == 0 : "Failed test 5!";

    Set<String> baseSet = new HashSet<String>(a);
    assert baseSet.size()==2 : "Failed test 6!";  

    b = new MultiSet<String>(a);
    assert a.equals(b) : "Failed test 7!";

    try {
        assert false;
        System.out.println("Please enable assertions!");
    }
    catch(AssertionError e) {
        System.out.println("Success!");
    }
    }
}

公共类多站点测试{
公共静态void main（字符串[]args）{
多集a=新的多集（）；
多集b=新的多集（）；
a、 添加（“Foo”）；
a、 添加（“酒吧”）；
a、 添加（“Foo”）；
System.out.println（“a:+a）；//测试toString
b、 添加（“酒吧”）；
b、 添加（“Foo”）；
b、 添加（“酒吧”）；
b、 添加（“Foo”）；
System.out.println（“b:+b”）；
断言！a.equals（b）：“测试1失败！”；//测试等于
断言b.remove（“Bar”）：“测试2失败！”；//测试移除
断言a.equals（b）：“测试3失败！”；
对于（字符串s:a）{//测试迭代器
断言b.remove:“测试4失败！”；
}
断言b.size（）==0：“测试5失败！”；
Set baseSet=新哈希集（a）；
assert baseSet.size（）==2：“测试6失败！”；
b=新的多集（a）；
断言a.equals（b）：“测试7失败！”；
试一试{
断言错误；
System.out.println（“请启用断言！”）；
}
捕获（断言错误）{
System.out.println（“成功！”）；
}
}
}

还有我的Multiset类：

public class MultiSet<E> extends AbstractCollection<E>
{
    private int size = 0;
    private Map<E, Integer> values = new HashMap<E, Integer>();

    public MultiSet()
    {

    }

    public MultiSet(Collection<E> c)
    {
        addAll(c);
    }

    public boolean add()
    {
        return false;
    }

    public boolean remove()
    {
        return false;
    }

    public Iterator<E> iterator()
    {
        return new Iterator<E>()
        {
            private Iterator<E> iterator = values.keySet().iterator();
            private int remaining = 0;
            private E current = null;

            public boolean hasNext()
            {
                return remaining > 0 || iterator.hasNext();
            }

            public E next()
            {
                if (remaining == 0)
                {
                    current = iterator.next();
                    remaining = values.get(current);
                }
                remaining--;
                return current;
            }
            public void remove()
            {
                throw new UnsupportedOperationException();
            }
        };
    }

        public boolean equals(Object object)
        {
            if (this == object) return true;
            if (this == null) return false;
            if (this.getClass() != object.getClass()) return false;
            MultiSet<E> o = (MultiSet<E>) object;
            return o.values.equals(values);
        }


        public int hashCode()
        {
            return values.hashCode()*163 + new Integer(size).hashCode()*389;
        }

        public String toString()
        {
            String res = "";
            for (E e : values.keySet());
                    //res = ???;
            return getClass().getName() + res;
        }

        public int size()
        {
            return size;
        }
    }

公共类MultiSet扩展了AbstractCollection
{
私有整数大小=0；
私有映射值=新的HashMap（）；
公共多集（）
{
}
公共多集（集合c）
{
阿道尔（c）；
}
公共布尔加法（）
{
返回false；
}
公共布尔删除（）
{
返回false；
}
公共迭代器迭代器（）
{
返回新的迭代器（）
{
私有迭代器迭代器=values.keySet（）.Iterator（）；
私有整数剩余=0；
私有E电流=零；
公共布尔hasNext（）
{
返回剩余>0 | |迭代器.hasNext（）；
}
公共教育
{
如果（剩余==0）
{
current=iterator.next（）；
剩余=值。获取（当前）；
}
剩余--；
回流；
}
公共空间删除（）
{
抛出新的UnsupportedOperationException（）；
}
};
}
公共布尔等于（对象）
{
如果（this==对象）返回true；
如果（this==null）返回false；
if（this.getClass（）！=object.getClass（））返回false；
多集o=（多集）对象；
返回o.values.equals（值）；
}
公共int hashCode（）
{
返回值.hashCode（）*163+新整数（大小）.hashCode（）*389；
}
公共字符串toString（）
{
字符串res=“”；
for（E:values.keySet（））；
//res=？？？；
返回getClass（）.getName（）+res；
}
公共整数大小（）
{
返回大小；
}
}

也许如果你能在添加或删除的过程中帮助我，那么我可能可以解决另一个问题

而且，我的equals似乎不能正常工作， 我不确定如何计算String-toString的“res”。不要介意我的返回声明，我稍后会加上一些括号等，使它看起来不错

谢谢你的帮助。

---

//克里斯

为什么不继续使用经过良好测试的谷歌s，而不是重新发明轮子呢？您可以从许多实现中选择一种：

• ConcurrentHashMultiset
• 枚举多集
• 转发多集
• HashMultiset
• 不可变多集
• LinkedHashMultiset
• 树集合

什么应该涵盖您的用例，或者——如果您真的想要的话——自己实现Multiset接口，查看默认实现的来源

编辑：

您的实现破坏了

Collecion

接口契约-对于

add（E）

，您不能返回

false

。阅读：

布尔加法（E）

参数：

e

-要确保其在此集合中存在的元素

返回：

true

如果此集合因调用而更改

抛出：

UnsupportedOperationException

-如果此集合不支持添加操作

如果要使用只读多集，请使用

ImmutableMultiset

（更具体地说）或实现

Multiset

---

的界面

add（E）

method抛出

UnsupportedOperationException

您应该显示您尝试添加/删除的内容。您还应该确切地说明出了什么问题。另外，您还有一个

size

变量，它似乎完全无用。要从我的MultiSetI中添加/删除对象，我查看了其中一些变量。那么，这行得通吗@为我的add方法重写公共布尔add（eo）{throw new UnsupportedOperationException（）；}？我编辑了我的答案以回应此评论-基本上你不能从

add

方法返回

false

，它破坏了收集契约。