CODEWITHSUNDEEP
java
Mr.D
Mr.D

Reputation: 7873

Java, Convert instance of Class to HashMap

If I have class like this:

class MyObject {
    public int myInt;
    public String myString;
}

Is it possible to convert instance of this class to HashMap without implementing converting code?

MyObject obj = new MyObject();
obj.myInt = 1; obj.myString = "string";
HashMap<String, Object> hs = convert(obj);

hs.getInt("myInt"); // returns 1
hs.getString("myString"); // returns "string"

Does Java provide that kind of solution, or I need to implement convert by myself?

My Class has more than 50 fields and writing converter for each field is not so good idea.

Upvotes: 21

Views: 53894

Answers (6)

A.Casanova
A.Casanova

Reputation: 1017

Updated approach using reflection:

  public static <T> Map<String, String> parseInnerClass(T classInstance) {
    LinkedHashMap<String, String> ret = new LinkedHashMap<>();

    for (Field attr : classInstance.getClass().getDeclaredFields()) {
      String attrValue = "";
      attr.setAccessible(true);

      try {
        attrValue = attr.get(classInstance).toString();
      } catch (IllegalAccessException | NullPointerException e) {
        // Do not add nothing
      }

      ret.put(attr.getName(), attrValue);
    }
    return ret;
  }

Upvotes: 0

profcalculus
profcalculus

Reputation: 291

With jackson library this is also possible

MyObject obj = new MyObject();
obj.myInt = 1;
obj.myString = "1";
ObjectMapper mapObject = new ObjectMapper();
Map < String, Object > mapObj = mapObject.convertValue(obj, Map.class);

Upvotes: 28

Abdul Mohsin
Abdul Mohsin

Reputation: 1435

If you don't want to use Reflection then you can use my trick. hope this may help for someone.

Suppose your class looks like this. 

public class MyClass {
         private int id;
         private String name; 
}

Now Override toString() method in this class. in Eclipse there is a shortcut for generating this method also. 

public class MyClass {
    private int id;
    private String name; 

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("MyClass [id=").append(id).append(", name=").append(name).append("]");
        return builder.toString();
    }

}

Now write a method inside this class that will convert your object into Map<String,String>

public Map<String, String> asMap() {
        Map<String, String> map = new HashMap<String, String>();
        String stringRepresentation = this.toString();
        if (stringRepresentation == null || stringRepresentation.trim().equals("")) {
            return map;
        }
        if (stringRepresentation.contains("[")) {
            int index = stringRepresentation.indexOf("[");
            stringRepresentation = stringRepresentation.substring(index + 1, stringRepresentation.length());
        }
        if (stringRepresentation.endsWith("]")) {
            stringRepresentation = stringRepresentation.substring(0, stringRepresentation.length() - 1);
        }
        String[] commaSeprated = stringRepresentation.split(",");
        for (int i = 0; i < commaSeprated.length; i++) {
            String keyEqualsValue = commaSeprated[i];
            keyEqualsValue = keyEqualsValue.trim();
            if (keyEqualsValue.equals("") || !keyEqualsValue.contains("=")) {
                continue;
            }
            String[] keyValue = keyEqualsValue.split("=", 2);
            if (keyValue.length > 1) {
                map.put(keyValue[0].trim(), keyValue[1].trim());
            }

        }
        return map;
    }

Now from any where in your application you can simply call this method to get your HashMap from the Object. Cheers

Upvotes: 0

Nicolas Filotto
Nicolas Filotto

Reputation: 44965

Something like that will do the trick:

MyObject obj = new MyObject();
obj.myInt = 1; obj.myString = "string";
Map<String, Object> map = new HashMap<>();
// Use MyObject.class.getFields() instead of getDeclaredFields()
// If you are interested in public fields only
for (Field field : MyObject.class.getDeclaredFields()) {
    // Skip this if you intend to access to public fields only
    if (!field.isAccessible()) {
        field.setAccessible(true);
    }
    map.put(field.getName(), field.get(obj));
}
System.out.println(map);

Output:

{myString=string, myInt=1}

Upvotes: 5

Mike Murphy
Mike Murphy

Reputation: 1046

You might consider using a map instead of a class.

Or have your class extend a map such as

public class MyObject extends HashMap<String, Object> {

}

Upvotes: 0

PKuhn
PKuhn

Reputation: 1360

You can use reflection for implementing this behavior. You can get all fields of the class you want to convert to map iterate over this fields and take the name of each field as key of the map. This will result in a map from String to object. 

Map<String, Object> myObjectAsDict = new HashMap<>();    
Field[] allFields = SomeClass.class.getDeclaredFields();
    for (Field field : allFields) {
        Class<?> targetType = field.getType();
        Object objectValue = targetType.newInstance();
        Object value = field.get(objectValue);
        myObjectAsDict.put(field.getName(), value);
    }
}

Upvotes: 10

Related Questions