Recursive call with Generic method in Java

Question

I am working on legacy code like below

public Map myMethod(Map arg){
      Map newMap = createMap(); //This method creates a new Map instance.
      Iterator entries = arg.entrySet().iterator();
      while (entries.hasNext()) {
          Entry thisEntry = (Entry) entries.next();
          Object key = thisEntry.getKey();
          Object value = thisEntry.getValue();

          if ( value instanceof Map){
               Map newElement = myMethod((Map)value); // Recursive call here
               newMap.put(key, newElement);
          }else if ( value instanceof String ){
               newMap.put(key, value);
          }
      }
      return newMap;
}

Obviously, I would like to adapt Generics. So I changed the method like,

public <K,V> Map<K,V> myMethod(Map<K,V> arg){
      Map<K,V> newMap = createMap(); //creates a new Map instance.
      for ( Entry<K,V> entry : arg.entrySet()){

          K key = entry.getKey();
          V value = entry.getValue();

          if ( value instanceof Map){
               V newElement = myMethod(value); // Recursive call here
               newMap.put(key, newElement);
          }else if ( value instanceof String ){
               newMap.put(key, value);
          }
      }
      return newMap;
}

My question is about the line of recursive calls. So far, I have tried

V newElement = myMethod(value); -> Compile Error
Map<K,V> newElement = myMethod(value); ->compile Error
V newElement = (V) myMethod((Map<?,?>)value); ->Type safety warning

--------- Edited ----------

The further assumption that I could make is

createMap() method could be changed to createMap(arg)
Element type of arg is not bounded to a specific Java type. This is a library method so it has to be generic

Are you sure that value is a Map of the right type? Then just cast to that type and ignore the warnings. — Sotirios Delimanolis
– Sotirios Delimanolis, Commented Jan 6, 2016 at 22:52
Problem is that V can be either String or Map<K,V> recursing itself. Map<K, Object> would work, and you would need the cast (with the safety warning, nothing can be done against that) — njzk2
– njzk2, Commented Jan 6, 2016 at 23:05
side note: your legacy code does not compile here : Map newElement = myMethod(value); because value is an object, not a Map — njzk2
– njzk2, Commented Jan 6, 2016 at 23:06

newacct · Accepted Answer · 2016-01-07 01:32:23Z

2

The logic of your code is not type-safe, so it's not possible to avoid a type-safety warning.

You create a new map using createMap(); that method is creating a new map blindly, with no information, so the class of map it creates is not necessarily the same as the class of arg that is passed in. That means your method myMethod() returns a map that is not necessarily of the same implementing class as the one that is passed in.

In your recursive call, you pass a map that we know is an instance of V into the recursive call, and you want the thing you get back out to be a V. But that is not necessarily true. For example, what if V were TreeMap, and the thing that is returned from the recursive call is a HashMap? Then it should not be able to cast to V, and there is no way you can safely get a V from that.

answered Jan 7, 2016 at 1:32

newacct

123k29 gold badges168 silver badges227 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

exiter2000 Over a year ago

Make sense. Assuming I change createMap() to the createMap(arg) which returns a new instance of given argument, would this method be type safe and I could enforce generics?

newacct Over a year ago

@exiter2000: It would be safer. But even if you change the signatures of the methods, I'm not sure you can avoid unchecked casts.

William Hipschman · Accepted Answer · 2016-01-06 22:56:56Z

-1

Your types are all messed up here.

Your method takes a

Map<K,V>

and returns a

Map<K,V>

That means the call

V newElement = myMethod(element);

must be

Map<K,V> newElement = myMethod(element);  //element is of type Map<K,V>

and the call

newMap.put(key, newElement);

means that newElement must also be of type V.

So you basically need String, Map, and V to all have some common super type. In the original code, Map is really

Map<Object, Object>

so the super type is Object.

I would back up, and ask yourself why you have a map that is storing both Maps and Strings. You should probably refactor them into objects that actually represent their types.

For instance, let's say it's a file system and the Map is a directory and the String is a File, then you should really create a FileObject that can be either a directory or a file, and your method signature becomes:

Map<K, FileObject> myMethod(Map<K, FileObject> map)

answered Jan 6, 2016 at 22:56

William Hipschman

11 bronze badge

2 Comments

exiter2000 Over a year ago

Since this method is used by other applications(over 100 calls made to this method) and it is sort of a library method, I cannot change the nature of heterogeneous elements. This is actually simplified version of the original method. The argument Map takes Integer, List, Double, Map as elements.

William Hipschman Over a year ago

Then generics won't really help you here. You need to cast, and it will be unchecked and give a warning. The compiler can't know beforehand if V is really the right type.

Collectives™ on Stack Overflow

Recursive call with Generic method in Java

2 Answers 2

2 Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related