Struggling with generics, "unchecked call to put()"

[Rob Marshall]

Hi,

This is probably something really simple, but I'm obviously not getting it...

I have the following example:

import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;

public class test_generics {
	public static void main (String[] args) {
		HashMap<String, HashMap> omap = new HashMap<String, HashMap>()
		{
			{
				put("OuterMap",		new HashMap<String, HashMap<String, String>>());
				put("OuterList",	new HashMap<String, List<String>>());
			}
		};

		HashMap<String, String> imap	= new HashMap<String, String>();
		imap.put("hash0", "this is 0");
		imap.put("hash1", "this is 1");
		omap.get("OuterMap").put("InnerMap", imap);

		List<String> ilist = new ArrayList<String>();
		ilist.add("item0");
		ilist.add("item1");
		omap.get("OuterList").put("InnerList",ilist);

		System.out.println("The Map: " + omap);
	}
}

I've tried every permutation that I can think of, and I can't seem to get rid of:

javac -Xlint:unchecked test_generics.java 
test_generics.java:19: warning: [unchecked] unchecked call to put(K,V) as a member of the raw type java.util.HashMap
                omap.get("OuterMap").put("InnerMap", imap);
                                        ^
test_generics.java:24: warning: [unchecked] unchecked call to put(K,V) as a member of the raw type java.util.HashMap
                omap.get("OuterList").put("InnerList",ilist);
                                         ^
2 warnings

Any ideas what I'm missing? The code works and I end up with what I want, but I would prefer to fix the warnings (as opposed to simply suppressing them).

Thanks,

Rob

[Sebastian Janisch]

You have an evil design going on there...

You will get warnings one or the other way, because you are mixing raw types with parameterized types.

Why not using two HashMaps? One that holds the String, Map combo, and the other the String, List.

[Rob Marshall]

Hi Sebastian,

Well, it gets more evil because I got this to work:

import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;

public class test_generics {
	public static void main (String[] args) {
		HashMap<String, HashMap> omap = new HashMap<String, HashMap>()
		{{
			put(new String("OuterMap"),	new HashMap<String, HashMap>()
			{{
				put(new String("InnerMap"), new HashMap<String, String>()
				{{
					put(new String("hash0"), new String("this is 0"));
					put(new String("hash1"), new String("this is 1"));
				}});
			}});
			put(new String("OuterList"),	new HashMap<String, List<String>>()
			{{
				put(new String("InnerList"), new ArrayList<String>()
				{{
					add("item0");
					add("item1");
				}});
			}});
		}};

		System.out.println("The Map: " + omap);
	}
}

You gotta love it

I think that the problem is trying to define things too early. What seems to work best (for me) is to keep the types closer to the actual definitions. In other words, rather than trying to define the whole HashMap up front (ala HashMap<String, HashMap<String, HashMap<String, String>>>, although I may not have tried that one... ), get more specific as I get to where I'm actually defining the maps/lists.

Thanks,

Rob

[Rob Marshall]

Oh, and by the way, the reason this looks so evil is because I'm reading in a configuration file that has multiple types of parameters it defines (it's also inconsistent in it's definitions...I didn't write it) with variable arguments and lists for the different parameters. But I want to keep all of the information in a single map.

Thanks again,

Rob

[Sebastian Janisch]

You just shifted away the problem.

Try adding

HashMap<String, String> imap  = new HashMap<String, String>();   
        imap.put("hash0", "this is 0");   
        imap.put("hash1", "this is 1");   
        omap.get("OuterMap").put("InnerMap", imap);   

like you did before, you'll get the same warning.

This design is super type unsafe.

[Rob Marshall]

Sorry, one more thing, all the "new String"'s are superfluous...I guess I went a little overboard

[Henry Wong]

HashMap<String, HashMap> omap = new HashMap<String, HashMap>()   
{   
    {   
        put("OuterMap",   new HashMap<String, HashMap><String, String>>());   
        put("OuterList",    new HashMap<String, List><String>>());   
    }   
};   

Am I reading this right? You are creating an anonymous inner class that extends the HashMap class, for the purpose so that, you can add an instance initializer, that preloads two key value pairs?

Creating a new class, just so that you can initialize a particular instance is a bit much, isn't it?

Henry

[Henry Wong]

Rob Marshall wrote:

		HashMap<String, HashMap> omap = new HashMap<String, HashMap>()
		{{
			put(new String("OuterMap"),	new HashMap<String, HashMap>()
			{{
				put(new String("InnerMap"), new HashMap<String, String>()
				{{
					put(new String("hash0"), new String("this is 0"));
					put(new String("hash1"), new String("this is 1"));
				}});
			}});
			put(new String("OuterList"),	new HashMap<String, List<String>>()
			{{
				put(new String("InnerList"), new ArrayList<String>()
				{{
					add("item0");
					add("item1");
				}});
			}});
		}};

You gotta love it

No I don't gotta... Creating 5 anonymous inner classes that just initializes one collection is too much. Don't you get annoyed having tons and tons of class files floating around?

Henry

[David Newton]

Oh, and by the way, the reason this looks so evil is because I'm reading in a configuration file that has multiple types of parameters it defines (it's also inconsistent in it's definitions...I didn't write it) with variable arguments and lists for the different parameters. But I want to keep all of the information in a single map.

Maybe it'd be cleaner to create a general "configuration parameter" interface with multiple implementations?

[Rob Marshall]

Hi Henry,

No, I guess you don't "gotta love it". I just thought it was funny that it actually worked

Here's another stab at it...I think this is better, but it could probably still be improved on:

import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;

public class test_generics {
	private static class Config {
		HashMap<String, HashMap> OuterMap;
		HashMap<String, List<String>> OuterList;
	}

	public static void main (String[] args) {
		Config conf	= new Config();

		conf.OuterMap = new HashMap<String, HashMap>();
		HashMap<String, String> imap  = new HashMap<String, String>();
		imap.put("hash0", "this is 0");
		imap.put("hash1", "this is 1");
		conf.OuterMap.put("InnerMap0", imap);

		System.out.println("The outer map: " + conf.OuterMap);

		conf.OuterList = new HashMap<String, List<String>>();
		List<String> ilist  = new ArrayList<String>();
		ilist.add("list0");
		ilist.add("list1");
		ilist.add("list2");
		conf.OuterList.put("InnerList0", ilist);

		System.out.println("The outer list: " + conf.OuterList);
	}
}

In case it wasn't obvious, I'm new to Java...so sometimes I play with things just to see what happens. I guess I got a little carried away. Sorry.

When I compile the above I end up with a test_generics$Config.class, which I understand (I think), but I also get a test_generics$1.class, what's that?

Hi David,

I'm not sure I follow you. What do you mean by a "configuration parameter interface"? I am trying to figure out how to read in the config file and hold the information somewhere, but I will actually just create an instance of "ConfigFile" and use "get" methods to give me the pieces I need...Is that what you're talking about?

Thanks,

Rob

[Sebastian Janisch]

The $1 thing refers to anonymous classes inside your code. Each anonymous class gets it's own file with an incrementing number.

Using your old implementation you had some of them. I can't spot any anonymous classes in your code, maybe the class file is from the old implementation...

[Rob Marshall]

Hi Sebastian,

I removed all the classes for test_generics.java and recompiled and the test_generics$1.class shows up again...

Thanks,

Rob

[Rob Spoor]

HashMap and Map are in the end still generic, so the full declaration should be this:

Map<String, Map<String, Object>> omap = new HashMap<String, Map<String, Object>>() ...

First of all, notice how I removed the references to HashMap in the variable type and the generics. It makes it possible to switch to TreeMaps or LinkedHashMaps later on. Second, the generic value type for the inner map must be Object because you want to put anything in it. Anything else will not work.