TreeSet contains 方法对我不起作用

Question

我想将自定义的数据放入 TreeSet 中。当自定义数量相同时，我添加贸易量。

这是我的 TradeNode 类，它实现了 Comparable Interator。

import java.util.Comparator;  

public class TradeNode implements Comparable<TradeNode> {  

    private String cstm; // custom number  

    private Integer mon = 0; // Trade  

    public TradeNode() {}  

    public TradeNode(String cstm, int mon) {  
        this.mon = mon;  
        this.cstm = cstm;  
    }  

    public int compareTo(TradeNode o) {  
        if (o.cstm.equals(this.cstm)) {  
            o.mon += this.mon;  
            return 0;  
        } else if (this.mon == o.mon) {  
            return this.cstm.compareTo(o.cstm);  
        } else {  
            //return (o.mon - this.mon);  
            return o.mon.compareTo(this.mon);  
        }  
    }  

    @Override  
    public boolean equals(Object obj) {  
        if (this == obj) {  
            return true;  
        }  
        if (obj == null) {  
            return false;  
        }  
        if (!(obj instanceof TradeNode)) {  
            return false;  
        }  
        TradeNode other = (TradeNode) obj;  
        if (cstm == null) {  
            if (other.cstm != null) {  
                return false;  
            }  
        } else if (!cstm.equals(other.cstm)) {  
            return false;  
        }  
        return true;  
    }  

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

    @Override  
    public String toString() {  
        return "[" + cstm + "] [" + mon + "]";  
    }  

    public int getMon() {  
        return mon;  
    }  

    public void setMon(Integer mon) {  
        this.mon = mon;  
    }  

    public String getCstm() {  
        return cstm;  
    }  

} 

测试类是：

public class Testtree {  
    public static void main(String[] args) {  
    TradeNode nd1 = new TradeNode("A", 100);  
        TradeNode nd2 = new TradeNode("B", 10);  
        TradeNode nd3 = new TradeNode("B", 1000);  
        TreeSet<TradeNode> tree = new TreeSet<TradeNode>();  
        tree.add(nd1);  
        tree.add(nd2);  
        tree.add(nd3);  
        for (TradeNode node : tree) {  
            System.out.println(node);  
        }  
    } 

我认为输出应该是这样的：

[B] [1010]  
[A] [100]

但是输出是

[B] [1000]  
[A] [100] 
[B] [10]

有人能帮助我并指出我的错在哪里吗？

如果我像这样改变compareTo()方法，它仍然不起作用。

public int compareTo(TradeNode o) {
        if (o.cstm.equals(this.cstm)) {
            return 0;
        } else {
            return o.mon.compareTo(this.mon);
        }
    }

结果是：

[B] [1000]
[A] [100]
[B] [10]

我尝试了Ben Xu的方法，代码如下： 我的新的compareTo()方法：

public int compareTo(TradeNode o) {
        if (o.cstm.equals(this.cstm)) {
            return 0;
        } else {
            return this.mon.compareTo(o.mon);
        }
    }

我的新的Testtree类：

public class Testtree {

    public static void main(String[] args) {
        TradeNode nd1 = new TradeNode("44010358010481", 150354);
        TradeNode nd2 = new TradeNode("44010358010481", 150641);
        TradeNode nd3 = new TradeNode("44010358010481", 270000);
        TradeNode nd4 = new TradeNode("44010039275685", 10000);
        TradeNode nd5 = new TradeNode("44010039275685", 980000);
        TradeNode nd6 = new TradeNode("44010039275685", 5000);
        TradeNode nd7 = new TradeNode("44010234235687", 10000);
        TradeNode nd8 = new TradeNode("44010234235687", 360000);
        TradeNode nd9 = new TradeNode("44010234235687", 53400);
        Map<String, Integer> map = new HashMap<String, Integer>(); 
        addTradeNode(map, nd1);
        addTradeNode(map, nd2);
        addTradeNode(map, nd3);
        addTradeNode(map, nd4);
        addTradeNode(map, nd5);
        addTradeNode(map, nd6);
        addTradeNode(map, nd7);
        addTradeNode(map, nd8);
        addTradeNode(map, nd9);

        Iterator<Entry<String, Integer>> iterator = map.entrySet().iterator();
        TradeNode t;
        List<TradeNode> list = new ArrayList<TradeNode>();
        while(iterator.hasNext()) {
            Map.Entry<String, Integer> m = iterator.next();
            t = new TradeNode(m.getKey(),m.getValue());
            list.add(t);
        }
        Collections.sort(list);
        for(TradeNode tn : list) {
            System.out.println(tn);
        }
    }

    private static void addTradeNode(Map<String, Integer> map, TradeNode node) {

        Integer integer = map.get(node.getCstm());
        if (integer == null) {
            map.put(node.getCstm(), node.getMon());
        } else {
            map.remove(node.getCstm());
            map.put(node.getCstm(), integer.intValue() + node.getMon());
        }

    }

}

结果是：

[44010234235687] [423400]
[44010358010481] [570995]
[44010039275685] [995000]

最后，它满足了我的要求。但我仍然不知道为什么这个新的compareTo()方法在下面的测试方法中不起作用：

public class Testtree2 {

    public static void main(String[] args) {
        TradeNode nd1 = new TradeNode("A", 100);
        TradeNode nd2 = new TradeNode("B", 10);
        TradeNode nd3 = new TradeNode("B", 1000);
        TreeSet<TradeNode> tree = new TreeSet<TradeNode>();
        tree.add(nd1);
        tree.add(nd2);
        tree.add(nd3);
        for (TradeNode node : tree) {
            System.out.println(node);
        }       
    }
}

结果是：

[B] [10]
[A] [100]
[B] [1000]

我认为它是：

[B] [10]
[A] [100]

有人能告诉我我的新compareTo()中的错误在哪里吗方法？非常感谢并感谢任何帮助我的人。

哈哈哈，我从JavaRanch得到了答案。有一个叫亨利的人告诉了我答案。现在我认为当我们在 TreeSet 中使用 contains() 方法时，它不会搜索该 Set 中的所有内容，它只搜索排序后的值。

新的 Testtree3 类是：

public class Testtree3 {

    public static void main(String[] args) {
    TradeNode nd1 = new TradeNode("A", 100);
        TradeNode nd2 = new TradeNode("B", 200);
        TradeNode nd3 = new TradeNode("B", 1000);
        TreeSet<TradeNode> tree = new TreeSet<TradeNode>();
        tree.add(nd1);
        tree.add(nd2);
        tree.add(nd3);
        for (TradeNode node : tree) {
            System.out.println(node);
        }
    }

}

，结果是：

[A] [100]
[B] [200]

哈哈。现在我将去查找 TreeSet 背后的代码。

Answer 1

TreeSet.add 并没有做你想象的那样。

如果它检测到某个值已经存在，它不会尝试将新值“添加”到现有值中 - 它只是返回而不更改集合。这只是一个基于集合的操作。

（此外，您的比较与 equals 方法不同步这一事实有点奇怪，并且 this.mon == o.mon 的比较不适合整数。）

Answer 2

运行结果为 ，可以检查再次运行程序。

[B] [1000]
[A] [100]
[B] [10]

结果是由于树集使用了您实现的比较器，

我不知道您想做什么。

但至少有一个明显的不好的做法：

public int compareTo(TradeNode o) {  
    if (o.cstm.equals(this.cstm)) {  
        o.mon += this.mon;  
        return 0;  
    } else if (this.mon == o.mon) {  
        return this.cstm.compareTo(o.cstm);  
    } else {  
        //return (o.mon - this.mon);  
        return o.mon.compareTo(this.mon);  
    }  
}  

你不应该在compareTo方法中改变它的值“o.mon += this.mon; ”，这非常令人困惑。

如果你想对所有同名的TreeNode求和，
不要使用 Collection ，而是使用 map 。

例如，使用 hashmap，键是 name 或（TreeNode 因为它等于并且 hashcode 仅使用 cstm ），值是 num。每次添加TreeNode时，检查是否存在同名，如果不存在，则添加到map，否则添加值。

以下是使用地图的示例代码：

public class Testtree {
public static void main(String[] args) {
    TradeNode nd1 = new TradeNode("A", 100);
    TradeNode nd2 = new TradeNode("B", 10);
    TradeNode nd3 = new TradeNode("B", 1000);
    Map<String, Integer> map = new HashMap<String, Integer>();
    addTreeNode(map, nd1);
    addTreeNode(map, nd2);
    addTreeNode(map, nd3);
    System.out.println(map);
}

private static void addTreeNode(Map<String, Integer> map, TradeNode node) {

    Integer integer = map.get(node.getCstm());
    if (integer == null) {
        map.put(node.getCstm(), node.getMon());
    } else {
        map.remove(node.getCstm());
        map.put(node.getCstm(), integer.intValue() + node.getMon());
    }

}
}

Answer 3

您确实不应该改变 TradeNode#compareTo(...) 中的参数。无法保证在进行比较时 TreeSet 是否会调用 newItem.compareTo(existingItem) 或 existingItem.compareTo(newItem)。

您可能应该修复您的 TradeNode#compareTo(...) ，以便它在不发生突变的情况下满足 Comparator 合约。

如果您想改变它包含的对象，我不确定 Set （TreeSet 或其他）是否真的是正确的数据结构。也许从 String 到 TradeNode 的 Map 会是更好的选择？

Answer 4

您的compareTo方法包含更改状态o.mon += this.mon;的代码，这是非常糟糕的设计，更糟糕的是，该状态用于确定compareTo if (this .mon == o.mon)。由于存在这种有毒关系，您的实现几乎肯定违反了compareTo的合同：请参阅其 javadoc

这太可怕了。消除 CompareTo 方法中的副作用样式状态更改。

public int compareTo(TradeNode o) {  
    if (o.cstm.equals(this.cstm)) {  
        o.mon += this.mon;    // ALARM BELLS!!! SIDE EFFECT!! ARRGGGHHH!
        return 0;  
    } else if (this.mon == o.mon) {  // AND THE SIDE EFFECT IS ALSO USED TO COMPARE! AVERT YOUR EYES! 
        return this.cstm.compareTo(o.cstm);  
    } else {  
        //return (o.mon - this.mon);  
        return o.mon.compareTo(this.mon);  
    }  
}