TreeSet contains method doesn't work for me??????

[hr rick]

I want to put the custom's data into a TreeSet. When the custom number is same, I add the volume of trade.
Here is my TradeNode class that implements the 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;
    }

}

and the test class is :

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);
        }
    }

I supposed the output shoud be like this :

[B] [1100]
[A] [100]

but the output is

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

Could someone help me and point me out where my fault is. Thanks a lot!

[Henry Wong]

Interesting idea. You don't know the total amount of trade, so you'll merge (add them up) them at sort time by adding them when a comparison is equal. Your compareTo() method is responsible for sort order -- which you decided to use the trade value (the amount to trade) itself.

hr rick wrote:
Could someone help me and point me out where my fault is. Thanks a lot!

1. The compareTo() method is used by the sorting algorithm to sort the element into the correct order. In order to do this, this method may be called many times during an insert -- not guaranteed to be called only once.

2. You are sorting on trade value, but this value is changing during the sort. In effect, the ordering has to change as the items are being inserted -- but the TreeSet class doesn't know this, and hence, the data structure will be different (ie. wrong and/or corrupted) as items are added.

Henry

[hr rick]

thank you, Henry.
I tested it in another Testclass.

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);
        TreeSet<TradeNode> tree = new TreeSet<TradeNode>();
        tree.add(nd1);
        tree.add(nd2);
        tree.add(nd3);
        tree.add(nd4);
        tree.add(nd5);
        tree.add(nd6);
        for (TradeNode node : tree) {
            System.out.println(node);
        }
    }

}

the output is :

[44010039275685] [980000]
[44010358010481] [570995]
[44010039275685] [15000]

I think I got something in your answer, and I think if i make it sync, would it work right? Thanks.
If doesn't , would you please tell me how can i make it?
sorry for my poor english

[Henry Wong]

hr rick wrote:
I think I got something in your answer, and I think if i make it sync, would it work right? Thanks.
If doesn't , would you please tell me how can i make it?

I think that totaling the trade data while inserting it into the TreeSet is not a good idea. Do those two tasks separately.... And if you don't want to do it separately, do if differently. Sort it differently that doesn't use trade count. Prior to add, check if the item is already in the list, and replace it with the new trade count. Do this logic with the add, and not in the compareTo() method.

Henry

[hr rick]

Ok, Henry. I updated my codes according to your idea.
Here is my update compareTo method:

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

and the output still like this:

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

I think it should be like this:

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

Where is my fault???

[Henry Wong]

hr rick wrote:
Where is my fault???

Same answer... the compareTo() method is used by the sorting algorithm to sort the element into the correct order. In order to do this, this method may be called many times during an insert -- not guaranteed to be called only once.

However, I guess I should add that there is also no reason to compare to every element either. For example, if the second B is compared to the A, and is determined to be less than that A, there is no reason to compare it to the earlier B that was compared to be more than that A. After all, how can two B's, one greater than A, the other less than A, be possibility equal?

Henry

[hr rick]

Thanks, Henry, you really solved my problem. now i'll go find the codes behinds the TreeSet to really solve it. Thank you!