How to convert hashmap to JSON object in Java

java

json-serialization

gson

jackson

byNikita Barsukov·Sep 13, 2024

Conquer the HashMap to JSON conversion using Jackson's ObjectMapper. The solution is essentially a one-liner:

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;

HashMap<String, Object> map = new HashMap<>();
map.put("key1", "value1");
map.put("key2", 42);
String json = new ObjectMapper().writeValueAsString(map); // Java + JSON = 💘
System.out.println(json);  // {"key1":"value1","key2":42}

Here, the map is converted to a JSON-formatted string, effectively transforming it into a JSON object.

Understanding alternative approaches

Working with HashMap to JSON conversions means being mindful of data sizes, nested structures, and post-conversion manipulations. Libraries like Gson and Jackson make it a piece of cake. Consider these approaches:

Gson library in action

import com.google.gson.Gson;
HashMap<String, Object> map = new HashMap<>();
map.put("moreThan", "meetsTheEye");
Gson gson = new Gson();
String json = gson.toJson(map);
System.out.println(json); // {"moreThan":"meetsTheEye"} - Autobots, rollout to JSON!

Jackson plays the game

import com.fasterxml.jackson.databind.ObjectMapper;
HashMap<String, Object> map = new HashMap<>();
map.put("oneRing", "toRuleThemAll");
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(map);
System.out.println(json); // {"oneRing":"toRuleThemAll"} - One map to convert them all!

Exploring serialization gotchas

Serializing with Gson or Jackson? Beware private fields, transient fields, custom serialization and exception handling:

Private fields: Both libraries can serialize private fields. No getter? No problem!
Transient fields: By default, transient fields are left out to avoid serializing temporary states. Because who wants a temporary tattoo in a JSON?
Custom serialization: Take control with custom serializers to define how your objects should be prepared for the JSON journey.
Error handling: Handle exceptions such as JsonProcessingException, because a caught exception today keeps the bugs away.

Handling complex and nested structures

Converting HashMap to JSON with nested objects or collections is easier than untangling earphones. Remember:

Nested maps handling: Gson and Jackson handle this intuitively. It's like JavaScript's JSON.parse() but with less crying!
JSON Formatting: Print JSON in a friendly format if humans are reading it. Or have you ever tried reading The Matrix?
Preprocessing the map: Sometimes you need to pre-cook the ingredients. Do what's needed before the actual conversion.

Adding JSON libraries using Maven

To make these libraries work harder for you than a rented mule, add their Maven dependencies in your pom.xml:

For Gson:

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version> // Version number found at the back of a cereal box
</dependency>

For Jackson:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.14.0</version> // Rumor has it, this version number can both cut ribbon and cake
</dependency>