Java TreeSet.contains（）不调用Overwrited equals

我对TreeSet的contains（）方法有问题。据我所知，contains（）应该调用包含对象的equals（），正如javadoc所说：

布尔java.util.TreeSet.contains（对象o）：如果此集合 包含指定的元素。更正式地说，如果和，则返回true 仅当此集合包含一个元素e，使得（o==null？e==null: o、 等于（e））

我想做的是： 我有一个树集列表，其中的结果对象有一个成员

字符串基字

。现在，我想将每个树集与所有其他树集进行比较，并为每一对树集列出它们共享的基本单词。为此，我对

treeSet1

遍历列表一次，对

treeSet2

遍历列表第二次，然后遍历

treeSet2

中的所有ResultObjects，并对每个对象运行

treeSet1.contains（ResultObject）

，以查看

treeSet1

是否包含具有此词库的结果对象。我调整了ResultObject的

比较方法和
等于方法。但似乎从未调用过我的
equals
。
有人能解释一下为什么这不起作用吗

您好，
丹尼尔

公共静态void getcrossion（ArrayList列表，int值）{
用于（树集树集：列表）{
//对于每个树集，我们再次遍历树集列表，从下一个树集开始
//我们在外环找到的那个
for（TreeSet-treeSet2:list.subList（（list.indexOf（TreeSet））+1，list.size（））{
//在这一点上，我们得到了两个不同的树集
HashSet intersection=新HashSet（）；
对于（结果：树集）{
//我们迭代第一个树集中的每个结果，看看第二个树集中是否也存在词库
//!!!
if（treeSet2.contains（结果））{
添加（result.wordbase）；
}
}
如果（！intersection.isEmpty（））{
交叉点。添加（交叉点）；
}
}
}
公共类结果实现了可比性{
公共结果（字符串字库，双结果[]）{
this.result=结果；
this.wordbase=wordbase；
}
公共字符串词库；
公开双[]结果；
公共int比较（差异分析结果o）{
如果（o==null）返回0；
返回this.wordbase.compareTo（o.wordbase）；
}
@凌驾
公共int hashCode（）{
最终整数素数=31；
int结果=1；
结果=素数*结果
+（（wordbase==null）？0:wordbase.hashCode（））；
返回结果；
}
//从未打过电话
@凌驾
公共布尔等于（对象obj）{
if（this==obj）
返回true；
if（obj==null）
返回false；
如果（getClass（）！=obj.getClass（））
返回false；
差异分析结果其他=（差异分析结果）对象；
if（wordbase==null）{
if（other.wordbase！=null）
返回false；
}如果（！wordbase.equals（other.wordbase））
返回false；
返回true；
}   
}

据我所知，contains（）应该调用包含对象的equals（）

不是for，不是。它调用
比较
：

基于树映射的NavigableSet实现。根据使用的构造函数，使用元素的自然顺序或在设置的创建时间提供的比较器对元素进行排序。


请注意，如果要正确实现set接口，set维护的顺序（无论是否提供显式比较器）必须与equals一致

您的
compareTo
方法当前与
equals
-
x不一致。compareTo（null）
返回0，而
x.equals（null）
返回false。也许您可以接受，但您不应该期望调用
equals
。
equals仅被调用（如果有的话）当通过
比较找到树中正确的分支时
。
    public static void getIntersection(ArrayList<TreeSet<Result>> list, int value){

          for (TreeSet<Result> treeSet : list){

    //for each treeSet, we iterate again through the list of TreeSet, starting at the TreeSet that is next
                //to the one we got in the outer loop
                for (TreeSet<Result> treeSet2 : list.subList((list.indexOf(treeSet))+1, list.size())){

                //so at this point, we got 2 different TreeSets 
                HashSet<String> intersection = new HashSet<String>();

                for (Result result : treeSet){  
                    //we iterate over each result in the first treeSet and see if the wordbase exists also in the second one                

//!!!
                    if (treeSet2.contains(result)){
                        intersection.add(result.wordbase);
                    }
                }
                if (!intersection.isEmpty()){
                    intersections.add(intersection);
                }
            }
        }


public class Result implements Comparable<Result>{

    public Result(String wordbase, double result[]){
        this.result = result;
        this.wordbase = wordbase;
    }

    public String wordbase;
    public double[] result;

    public int compareTo(DifferenceAnalysisResult o) {

        if (o == null) return 0;

        return this.wordbase.compareTo(o.wordbase);
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result
                + ((wordbase == null) ? 0 : wordbase.hashCode());
        return result;
    }

//never called
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        DifferenceAnalysisResult other = (DifferenceAnalysisResult) obj;
        if (wordbase == null) {
            if (other.wordbase != null)
                return false;
        } else if (!wordbase.equals(other.wordbase))
            return false;
        return true;
    }   
}