HashMap of ArrayList<String>, String is not working properly?

The ArrayList#hashCode() is returning the same for all of them. If you look at the sourcing for it: http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/AbstractList.java#AbstractList.hashCode%28%29

You can see that should there be no elements, or all the same elements, that the hashCode would be the same.

Fix that up and it should work fine. Use either a Map or change the hashCode in one way or another.

Try this:

Map<String,List<String>> test = new HashMap<String,List<String>>();
test.put("s1", new ArrayList<String>());
test.put("s2", new ArrayList<String>());
test.put("s3", new ArrayList<String>());

System.out.println(test.size());

Note that a map is a key-value relation. For this reason, you may want too use the String as a key and the ArrayList as the values, instead of the other way around. This way, if you add 3 different Strings, each one will have a different hash value (hashcode). Thus, you will have 3 different keys in your Map.

Note also that:

put

public Object put(Object key, Object value) Associates the specified value with the specified key in this map. If the map previously contained a mapping for this key, the old value is replaced.

This is why you are getting 1, instead of 3, because you were adding the same object new ArrayList<String>().

Take look in more detail into the Class HashM specifications.

You use ArrayList as the key, try

    System.out.println(new ArrayList<String>().equals(new ArrayList<String>()));

it prints

true

The best approach would be to use the String object as key and the List as value.

Have a look at what java docs say here.

And if at all you want to add the ArrayList as key then overriding equals method should suffice.

The post here gives good insights. I have put some which I liked from that post.

Overriding equals for two ArrayLists:

 public boolean equals(List<String> one, List<String> two){
    if (one == null && two == null){
        return true;
    }

    if((one == null && two != null) 
      || one != null && two == null
      || one.size() != two.size()){
        return false;
    }

    //to avoid messing the order of the lists we will use a copy
    //as noted in comments by A. R. S.
    one = new ArrayList<String>(one); 
    two = new ArrayList<String>(two);   

    Collections.sort(one);
    Collections.sort(two);      
    return one.equals(two);
}

I'm not sure why you need the list as the key and the string as the value, but you are basically using the same 'key' for each put operation since the hashcode is the same for any empty list. Like the other answers mention, it's probably best to switch the list as the value and the string as the key. If the list changes, any future attempts at .get will return null

   public static void main(String...args) {
       Map<List<String>, String> test = new HashMap<List<String>, String>();
       List<String> bob = new ArrayList<>();
       bob.add("asdf");
       test.put( new ArrayList<String>(), "s1");
       test.put( bob, "s2");

       System.out.println(test.size());
       System.out.println(test.get(bob));
   }

outputs

2
s2

When a new item gets added like

   public static void main(String...args) {
       Map<List<String>, String> test = new HashMap<List<String>, String>();
       List<String> bob = new ArrayList<>();
       bob.add("asdf");
       test.put( new ArrayList<String>(), "s1");
       test.put( bob, "s2");      
       bob.add("aabbcc");

       System.out.println(test.size());
       System.out.println(test.get(bob));
   }

The get will not work, since the hash of the list has changed. The output in this case would be:

2
null