Converting Object To Map in Java

1. Introduction

Converting an Object to a Map can be useful in Java when we seek to transform an object’s properties into a key-value representation. It could be helpful, especially when dealing with data manipulation, serialization, or when we need to pass object data to other parts of our program.

In this tutorial, we’ll explore three different approaches to converting an Object to a Map in Java using reflection, Jackson, and Gson APIs.

2. Using Reflection

Reflection is a powerful feature in Java that allows us to inspect and manipulate classes, interfaces, fields, methods, and other components at runtime. Moreover, it provides the ability to access information about the structure of a class, invoke methods dynamically, and even modify private fields.

Below is a class named Employee that represents an employee with a private name and salary, providing getters and setters to access and modify these attributes:

private static class Employee {
    private String name;
    private Double salary;

    // getters and setters
}

The following test method uses reflection to convert a Java object (employee) into a Map, using the object’s field names as keys and their values as values:

@Test
public void givenJavaObject_whenUsingReflection_thenConvertToMap() throws IllegalAccessException {
    Map<String, Object> map = convertUsingReflection(employee);
    Assert.assertEquals(employee.getName(), map.get("name"));
    Assert.assertEquals(employee.getAge(), map.get("salary"));
}

private Map<String, Object> convertUsingReflection(Object object) throws IllegalAccessException {
    Map<String, Object> map = new HashMap<>();
    Field[] fields = object.getClass().getDeclaredFields();

    for (Field field: fields) {
        field.setAccessible(true);
        map.put(field.getName(), field.get(object));
    }

    return map;
}

In the above test, we handled the conversion process using a private method convertUsingReflection, which accesses the object’s fields using the .getClass().getDeclaredFields().

What if we consider incorporating an Address object within the Employee object?

This would allow us to associate each employee with their specific address information. However, it’s important to note that using reflection, a mechanism that dynamically provides access to object properties, might not function seamlessly in this context.

While we won’t delve into the specifics of resolving this issue, it’s worth mentioning the potential challenges of incorporating reflection when dealing with nested objects like ‘Address’ within ‘Employee’.

3. Using Jackson

When converting an Object into a Map, Jackson provides multiple approaches. Jackson is a versatile library renowned for its excellent support of various conversion types, such as JSON or XML.

The following example shows how we can convert a Java object (employee) into a map using Jackson:

@Test
public void givenJavaObject_whenUsingJackson_thenConvertToMap() {
    ObjectMapper objectMapper = new ObjectMapper();
    Map<String, Object> map = objectMapper
      .convertValue(employee, new TypeReference<Map<String, Object>>() {});
    Assert.assertEquals(employee.getName(), map.get("name"));
    Assert.assertEquals(employee.getAge(), map.get("salary"));
}

In the above code, we used ObjectMapper class from Jackson to perform the conversion by invoking the convertValue method. Furthermore, the resulting map has the employee object’s field names as keys and their corresponding values.

Here’s another example showcasing the Jackson library to transform a Java object (employee) into a map representation while dealing with nested objects like Address within Employee:

Employee employee = new Employee("John", 3000.0, new Address("123 Street", "City"));
@Test
public void givenJavaObject_whenUsingJackson_thenConvertToMap() {
    ObjectMapper objectMapper = new ObjectMapper();
    SimpleModule module = new SimpleModule();
    module.addSerializer(Address.class, new AddressSerializer());
    objectMapper.registerModule(module);
    Map<String, Object> map = objectMapper.convertValue(employee, new TypeReference<>() {});
    Assert.assertEquals(employee.getAddress().getStreet(), ((Map<?, ?>) map.get("address")).get("street"));
    Assert.assertEquals(employee.getAddress().getCity(), ((Map<?, ?>) map.get("address")).get("city"));
}

This test aims to serialize the values of the Address object using the JsonSerializer class. In this case, before serializing the Address object, the code performs an extra process. Apart from serializing the Address object, the code verifies whether the street and city values within the Employee object are consistent with the values stored in the nested map.

4. Using Gson

Gson is an alternative way to utilize the fromJson() method to convert an object to JSON and then convert the JSON into a HashMap in a subsequent step.

The following test uses Gson to convert a Java object (employee) into a map.

@Test
public void givenJavaObject_whenUsingGson_thenConvertToMap() {
    Gson gson = new Gson();
    String json = gson.toJson(employee);
    Map<String, Object> map = gson.fromJson(json, new TypeToken<Map<String, Object>>() {}.getType());
    Assert.assertEquals(employee.getName(), map.get("name"));
    Assert.assertEquals(employee.getAge(), map.get("salary"));
}

As shown above, the conversion process involves serializing the employee object to a JSON string using the toJson method and then de-serializing the JSON string into a map using the fromJson method.

Let’s consider another example where we utilize the Gson library to represent the Java object (employee) as a map handle in case of nested objects, such as the Address:

@Test
public void givenJavaObject_whenUsingGson_thenConvertToMap() {
    Gson gson = new Gson();
    String json = gson.toJson(employee);
    Map<String, Object> map = gson.fromJson(json, new TypeToken<Map<String, Object>>() {}.getType());
    Assert.assertEquals(employee.getAddress().getStreet(), ((Map<?, ?>) map.get("address")).get("street"));
    Assert.assertEquals(employee.getAddress().getCity(), ((Map<?, ?>) map.get("address")).get("city"));
}

The above test checks if the street and city variables of the Address object match the values stored in a nested map under the key “address“.

5. Reflection vs. Jackson vs. Gson

The following table summarizes the key differences between the three different approaches:

Factors

Reflection

Jackson

Gson

Ease of Use

Requires explicit code for field access

High-level API for easy conversion

Flexibility

Allows direct access to private fields

Supports various object structures

Performance

Moderate

Fast and efficient

Dependencies

No external dependencies required

Requires the Jackson library

Requires the Gson library

Customization

Can be customized for specific needs

Customizable through annotations

Support for Complex Types

Limited support for nested objects

Comprehensive support for complex types

Integration

Native to Java

Popular and widely adopted

6. Conclusion

In conclusion, exploring various approaches such as reflection, Jackson, and Gson enables us to convert Objects to Java Maps, facilitating seamless integration and manipulation of object data in diverse scenarios.

As always, the code is available over on GitHub.

Persistence

REST

Security