1. Introduction
In this tutorial, we’ll explore how to convert a Gson JsonArray to a HashMap in Java. By the end of this tutorial, we’ll understand the process of iterating over a JsonArray, extracting its elements, and storing them in a HashMap.
2. Understanding Gson JsonArray and HashMap Structures
A Gson JsonArray is a part of the Gson library and we use it to represent an array of JSON elements. Here’s an example structure of a JsonArray:
[
{"name": "John Doe", "age": 35},
{"name": "Mary Jenn", "age": 41}
]
On the other hand, a HashMap is a collection that stores key-value pairs, where each key maps to a specific value. Each key in the HashMap must be unique, meaning that no two keys can map to the same value. If we attempt to add a duplicate key, the new value overwrites the existing value associated with that key.
3. Iterative Approach
In this approach, we manually iterate over each element of the JsonArray object and populate a HashMap with the key-value pairs extracted from each JsonObject:
Map<String, Integer> convertUsingIterative (JsonArray jsonArray) {
Map<String, Integer> hashMap = new HashMap<>();
for (JsonElement element : jsonArray) {
JsonObject jsonObject = element.getAsJsonObject();
String type = jsonObject.get("name").getAsString();
Integer amount = jsonObject.get("age").getAsInt();
hashMap.put(type, amount);
}
return hashMap;
}
We start by creating an empty HashMap to store the resulting key-value pairs. Then, we loop through each element in the JsonArray. Each JsonElement is converted to a JsonObject to facilitate the extraction of its fields.
When using Gson, numeric values are often represented as JsonPrimitive objects containing Number instances. In this example, we extract the values of name and age from the jsonObject using getAsString() and getAsInt() methods respectively.
In addition, to validate this approach, we can create a test case that constructs a sample JsonArray and asserts the expected results.
Before running our tests, we can use the @BeforeEach annotation to set up some test data:
@BeforeEach
void setUp() {
jsonArray = new JsonArray();
JsonObject jsonObject1 = new JsonObject();
jsonObject1.addProperty("name", "John Doe");
jsonObject1.addProperty("age", 35);
jsonArray.add(jsonObject1);
JsonObject jsonObject2 = new JsonObject();
jsonObject2.addProperty("name", "Mary Jenn");
jsonObject2.addProperty("age", 41);
jsonArray.add(jsonObject2);
}
We can now proceed to write a test case that validates the conversion of a JsonArray to a HashMap:
Map<String, Integer> hashMap = JSONArrayToHashMapConverter.convertUsingIterative(jsonArray);
assertEquals(35, hashMap.get("John Doe"));
assertEquals(41, hashMap.get("Mary Jenn"));
This approach is straightforward and effective for scenarios where we need precise control over each element in the JsonArray.
4. Streams Approach
The second approach utilizes Java Streams, allowing us to perform the conversion in a more functional and concise manner. This method efficiently processes each element in the JsonArray and accumulates the results into a HashMap:
Map<String, Integer> convertUsingStreams (JsonArray jsonArray) {
return StreamSupport.stream(jsonArray.spliterator(), false)
.map(JsonElement::getAsJsonObject)
.collect(Collectors.toMap(
jsonObject -> jsonObject.get("name").getAsString(),
jsonObject -> jsonObject.get("age").getAsInt()
));
}
We begin by creating a stream from the JsonArray. We achieve this with the StreamSupport.stream() method, which takes a Spliterator for the JsonArray and a flag indicating whether the stream should be parallel (in this case, false for sequential processing).
In the map() function, each JsonElement is converted to a JsonObject, which allows us to extract specific fields from the JSON objects. Next, we use the collect() method with Collectors.toMap() to gather these JsonObject entries into a HashMap.
To ensure this method works correctly, we can create a similar test case:
Map<String, Integer> hashMap = JSONArrayToHashMapConverter.convertUsingStreams(jsonArray);
assertEquals(35, hashMap.get("John Doe"));
assertEquals(41, hashMap.get("Mary Jenn"));
We can use this method for processing large datasets efficiently and it’s well-suited for functional programming enthusiasts as well.
5. Using fromJson() Approach
In the final approach, we utilize Gson’s fromJson() method to convert a JsonArray into a list of maps. This approach leverages Gson’s built-in functionality to simplify the conversion process and then merges these maps into a single HashMap:
Map<String, Integer> convertUsingGson(JsonArray jsonArray) {
Map<String, Integer> hashMap = new HashMap<>();
Gson gson = new Gson();
List<Map<String, Object>> list = new Gson().fromJson(jsonArray, List.class);
for (Map<String, Object> entry : list) {
String type = (String) map.get("name");
Integer amount = ((Double) map.get("age")).intValue(); // Gson parses numbers as Double
hashMap.put(type, amount);
}
return hashMap;
}
First, we use Gson to parse the JsonArray and convert it into a list of Map objects. Each Map represents a JSON object with key-value pairs. We iterate through each map object in the list and extract the name field as a String and the age field as a Double.
Moreover, we convert the age value to an Integer using intValue() because Gson parses numbers as Double by default. Let’s validate our implementation:
Map<String, Integer> hashMap = JSONArrayToHashMapConverter.convertUsingGson(jsonArray);
assertEquals(35, hashMap.get("John Doe"));
assertEquals(41, hashMap.get("Mary Jenn"));
6. Conclusion
In this article, we’ve explored three methods to convert a Gson JsonArray to a HashMap in Java. The iterative method is useful for complex transformations, the stream approach is ideal for handling large JSON datasets efficiently. In contrast, the Gson method is best suited for straightforward conversions.
As always, the source code for the examples is available over on GitHub.