Java - is adding a key/value to a map within a map in 1 line of code possible?

((Map)map1.get(subCategoryMap)).put(newKey, newValue);

Or, use generics:

Map<X, Map<Y,Z>> map1;

...

map1.get(subCategoryMap).put(newKey, newValue);

However, both techniques will fail with NullPointerException if map1 doesn't contain a mapping for subCategoryMap.

Just an aside (I'd make this a comment but I think it will be slightly long)...

It feels very good for a programmer to be able to get a single conceptual operation on one line. To the programmer (at the time) it feels more readable, logical and just feels right.

It is almost never a good thing. For one thing, later it will be harder to parse than two lines--even if your gut reaction now is that it is more readable. Also--the more operations on one line, the harder it is to debug.

For readability, I'd say the Generics solution is about as much as I'd put on a single line--for the casting solution I'd break it down into two lines; I'd also break it down into multiple lines if either of the parameters were operations instead of just simple variables.

I know a lot of people won't agree with this and to tell you the truth I tend to put quite a bit on one line at first, but what I've noticed is that at the first sign of trouble or any confusion, it makes my life easier to break everything down into separate statements with clearly named variables.

At least as important--in cases with nested collections, I will often wrap the collections in a different object as well. This would be interesting in your case--the call would become a little more clear.

dataHolder.put(category, newKey, newVale);

Hides the mechanics of the nesting of the collections (which otherwise can be complex to remember correctly and easy to screw up) and makes your intent much clearer.

This pattern of wrapping (Not extending but encapsulating) nested collections feels strange at first but I really suggest you just give it a try--it really cleans up a LOT of code, makes everything much safer adds to everybody's comprehension, changes a "Collection" to a business object (where you can place business methods--a refactoring you will appreciate almost immediately), and just generally helps your code all over.

If you aren't using Generics, then a HashMap stores and retrieves the keys and values as Object, so you might need to cast, which would look something like this:

((HashMap)map1.get(subCategoryMap)).put(newKey, newValue);

However, it would be helpful if you provided more code.

If you use Generic collections, then your code should work as written. Otherwise, you need to add in the appropriate casts into your single line.

As long as map1 is declared something like Map<OuterKey, Map<InnerKey, MyValue>>, a one-liner will work. However, you need to be careful about what happens if subCategoryMap doesn't exist in map1—a one-liner will raise a NullPointerException.

Works fine if you use generics:

Map<String,Map<String,Integer>> map = new HashMap<String,Map<String,Integer>>();
map.put("Test", new HashMap<String,Integer>());
map.get("Test").put("Some", 1);

You can use ((HashMap)map1.get(subCategoryMap)).put(newKey, newValue);

Also, if you are using Java 5 or Java 6, you can use generic to avoid the cast in HashMap