Why Java TreeMap not printing all its inserted entries

Question

Pls tell what is wrong is happening here. I have a Person class which I'm using as a key in TreeMap. I have implemented Comparable also so that TreeMap can do sorting.

public class Person implements Comparable{

private String name;
private int age;
// getters and setters were omitted
@Override
public int compareTo(Object o) {
    return 0;
}
}

Now I created TreeMap and added values in it as:

Map treeMap=new TreeMap<Person,Object>();

treeMap.put(new Person(), "String1");
treeMap.put(new Person(), "String2");
treeMap.put(new Person(), "String3");
treeMap.put(new Person(), "String4");

System.out.println(treeMap);

After printing directly using System.out.println(treeMap); Iam only getting the last inserted value ie

Output:{Person@4aa36c=String4}

I know keys should be different but new operator always create a new object so I think its fine. But Iam helpless to figure out what is wrong going on here.

Answer 1

You are likely placing items in the Map backwards and would more than likely want the Person object as the value and the String as the key. But first you need to enhance your Person object with a Constructor to allow you to set the name at least, and maybe the age. Add a constructor to `Person':

public Person(String n, int a){
   this.name = n;
   this.age = a;
}

Then you can reorder how you add elements to the Map:

 Person p1 = new Person("Bob Jones", 32);
 treeMap.put(p1.getName(), person);

Additionally, TreeMap uses the compareTo method to determine where to place the entry in the Map for the keys. So, if you intend to use the Person object as the key, you need to implement the compareTo method. But your compareTo method is not implemented correctly and simply returns 0 for every element, causing your elements to overwrite each others location in the Map:

@Override
public int compareTo(Object o) {
    / TODO Auto-generated method stub
    return 0;
}

You need to properly implement the method contents (Hence the TODO statement).

Maybe add a social security number (SSN) to the Person class:

Long ssn;

public void setSsn(Long value){
    ssn = value;
}

public Long getSsn(){
    return ssn;
}

Then you could compare on ssn:

@Override
public int compareTo(Object o) {
    if(o == null) return 1;
    Person op = (Person)o;
    return ssn.compareTo(op.getSsn());
}

But if you just want to create some type of combination with what you have, maybe concatenate the name and age to try to have uniqueness:

@Override
public int compareTo(Object o) {
    if(o == null) return 1;
    Person op = (Person)o;
    return (name + age).compareTo(op.getName() + op.getAge());
}

Answer 2

You overrode toCompare method incorrectly. It always returns 0. So, all objects in the tree will be interpreted as the same and your treeMap always contains only the value that had been added the last.

I suggest you consider the compact (but not general as @4castle noted) solution.

@Override
public int compareTo(Person o) {
    if (age != o.age) return age > o.age ? 1 : -1;
    return name.compareTo(o.name);
}

If you changed the first line of the class declaration to

public class Person implements Comparable<Pesron>

Answer 3

TreeMap uses compareTo method of Comparable (not equals method from Object) when it tries to put an element into Map. Since your compareTo method implementation returns 0 for all Person objects, there can only be one element in TreeMap.

So when you try to put multiple Person keys, TreeMap only updates value, since for it all Person objects are same (as per your implementation for compareTo).

Here is code snippet for TreeMap.put from Java-8

    // split comparator and comparable paths
    Comparator<? super K> cpr = comparator;
    if (cpr != null) {
        do {
            parent = t;
            cmp = cpr.compare(key, t.key);
            if (cmp < 0)
                t = t.left;
            else if (cmp > 0)
                t = t.right;
            else
                return t.setValue(value);
        } while (t != null);
    }
    else {
        if (key == null)
            throw new NullPointerException();
        @SuppressWarnings("unchecked")
            Comparable<? super K> k = (Comparable<? super K>) key;
        do {
            parent = t;
            cmp = k.compareTo(t.key);
            if (cmp < 0)
                t = t.left;
            else if (cmp > 0)
                t = t.right;
            else
                return t.setValue(value);
        } while (t != null);
    }

So first it checks, whether Comparator is provided, if yes, TreeMap uses compare method to compare keys otherwise it uses compareTo method of Comparable for comparison.

Answer 4

Keys aren't unique based on their memory address, they are unique based on having a unique value. All of your Person objects are practically identical, but what's more, all of your Person objects claim to be "equal" to any other Person object given your current compareTo implementation (0 means equal).

The parameter order for the put method is key first, value second. You need to rearrange the put statements so that something unique is in front (the string), and therefore make all the entries unique.

treeMap.put("String1", new Person());
treeMap.put("String2", new Person());
treeMap.put("String3", new Person());
treeMap.put("String4", new Person());

Now there's no need to implement Comparable or have the compareTo method in Person.

If you require that the Person object be a key, you will have to make each one unique by giving it a unique variable with which to use the compareTo method properly. The best solution is to add a required ID number to each Person object, or otherwise use the name and age as the unique value for the object. Add on this code to Person:

private int id;
private static int numPeople = 0;
public Person() {
    numPeople++;
    id = numPeople;
    name = "";
}
@Override
public int compareTo(Person o) {
    if (age != o.age) return age > o.age ? 1 : -1;
    if (!name.equals(o.name) return name.compareTo(o.name);
    return id > o.id ? 1 : -1;
}

with

public class Person implements Comparable<Person>