Use HashMap to create dynamic function call

Question

I am trying to create a function call using hashmap.
For example,

Hashmap-- "a" -> "b" "c" -> "d"

Now I should parse this Hashmap and create a function like this-

someFun("{a:#,c:#}",new SomeClass(b),new SomeClass(d));

As you can see, a and c are keys of hashmap(first argument) ;
b and d are used to create objects (second argument and so on..)
someFun parameters depend on HashMap size..

I am confused!
Because I can loop through the map to get Keys and easily create the first argument.
For the second argument, I can use the value to create Objects.
But now how do I add these together to make the function call as specified?
Any help would be very much appreciated :)

P.S: My question is not about getting values/keys from hashmap,but using them to create a function call something as specified.I am not allowed to change someFun consider it as API call.

Answer 1

Is it something like this, that you need:

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map.Entry;

public class Draft {

public static class SomeClass{

    final private String val;

    public SomeClass(String val) {
        this.val = val;
    }
}

public void someFun(String str, SomeClass ... classes) {
    System.out.println("someFun" + str + Arrays.toString(classes));
}

public static void main(String[] args) {
    HashMap<String, String> keyToParam = new HashMap<>();
    keyToParam.put("a", "b");
    keyToParam.put("c", "d");
    String strArg = null;
    SomeClass[] classes = new SomeClass[keyToParam.size()];
    int pointer = 0;
    for(Entry<String, String> entry: keyToParam.entrySet()) {
        strArg += entry.getKey() + ":#";
        classes[pointer++] = new SomeClass(entry.getValue());
    }
    new Draft().someFun(strArg, classes);
}

}

Answer 2

First, you should define function like this:

public void someFun(String str, SomeClass[] someClasses) {
    // do something
}

Or this:

public void someFun(String str, SomeClass... someClass) {
    // do something
}

The former would be better because it's easy to call it by Java Reflection.

Then go through the hashmap and concentrate all keys to a string someString as the first parameter. While doing the iteration, you put all the values into an array someClasses as the second parameter.

Finally get the method and invoke it by (assume that we use SomeObject someObject to call the function):

Method method = SomeObject.getClass().getMethod("someFun");
method.invoke(someObject, new Object[] {someString, someClasses});

Answer 3

To get the HapsMap Key values

    HashMap<Object, Object> hashMap= new HashMap<Object,Object>();
    ...
    Set<Object> keyValueSet=hashMap.keySet();
    for ( Object keyValue : keyValueSet) {
      //you get the key from keyValue and the corresponding value from hashMap using this 
      hashMap.get(keyValue);
    }

The rest is your logic, you can use the values in any place you want.

Answer 4

Try this way...

try {
Object obj = new Object();// Create a new instance of the class that contain your method.
Method m = obj.getClass().getMethod("methodName", param1.class, param2.class, ..);
// In your case Method m = obj.getClass().getMethod("someFun", String.class,SomeClass.class,SomeClass.class);
m.invoke(obj, "{a:#,c:#}", new SomeClass(b),new SomeClass(d));
}catch (SecurityException e) {
  // ...
} catch (NoSuchMethodException e) {
  // ...
}catch (IllegalArgumentException e) {
} catch (IllegalAccessException e) {
} catch (InvocationTargetException e) {
}

Method implementation :

public static void someFun(String name, SomeClass classes ...) {

    for (SomeClass cls : classes) {
        //Logic here
    }
}