Course – LS – All
announcement - icon

Get started with Spring Boot and with core Spring, through the Learn Spring course:

>> CHECK OUT THE COURSE

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. This can be very 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, which 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 the 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 High-level API for easy conversion
Flexibility Allows direct access to private fields Supports various object structures Supports various object structures
Performance Moderate Fast and efficient 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 Customizable through annotations
Support for Complex Types Limited support for nested objects Comprehensive support for complex types Comprehensive support for complex types
Integration Native to Java Popular and widely adopted Popular and widely adopted

6. Conclusion

In this article, we explored various approaches, such as reflection, Jackson, and Gson, that enable 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.

Course – LS – All
announcement - icon

Get started with Spring Boot and with core Spring, through the Learn Spring course:

>> CHECK OUT THE COURSE

res – REST with Spring (eBook) (everywhere)
Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.