JSON String to Map

1. Overview

Handling JSON data is a common task in modern software development. There are several libraries we can use in Kotlin to work with JSON. One is provided by the Kotlin team, and there are several third-party libraries like org.json, Jackson, and Gson. In this article, we’ll explore how to convert a JSON string into a Map in Kotlin using various libraries.

2. kotlinx.serialization

In Kotlin, the kotlinx.serialization library allows us to easily serialize and deserialize data between a JSON representation and Kotlin objects.

First, we need to ensure we’ve added the kotlinx-serialization-json dependency to our project:

<dependency>
    <groupId>org.jetbrains.kotlinx</groupId>
    <artifactId>kotlinx-serialization-json</artifactId>
    <version>${serialization.version}</version>
</dependency>

This library returns strongly typed objects when parsing JSON, and parseToJsonElement() can return a JsonPrimitive, JsonArray, or JsonObject. This technique only works for JsonObject instances, since JsonObject extends Map<String, JsonElement>. We can parse the JSON String, and then implicitly cast it to a Map after we’ve confirmed it is a JsonObject:

fun jsonStringToMapWithKotlinx(json: String): Map<String, JsonElement> {
    val data = Json.parseToJsonElement(json)
    require(data is JsonObject) { "Only Json Objects can be converted to a Map!" }
    return data
}

3. org.json.JSONObject

The org.json package is another option that provides good support for working with JSON in Kotlin. For this, we need first to add the proper dependency to our project:

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>${org.json.version}</version>
</dependency>

Next, we use its JSONObject class, which provides a handy constructor method that takes a string parameter representing the JSON we want to deserialize. After we’ve constructed our JSONObject, we can use the convenience method toMap() to convert it to a Map:

fun jsonStringToMapWithOrgJosn(json: String): Map<String, Any> {
    val jsonObj = JSONObject(json)
    return jsonObj.toMap()
}

4. Gson

To work with the Gson library we need first to add the dependency to our project:

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>${gson.version}</version>
</dependency>

To convert a JSON string into a Map, Gson offers a function that takes the JSON string and a TypeToken. We can create this TypeToken with our generic Map to directly deserialize to the expected form:

fun jsonStringToMapWithGson(json: String): Map<String, Any> {
    val gson = Gson()
    val type = object : TypeToken<Map<String, Any>>() {}.type
    return gson.fromJson(json, type)
}

5. Jackson

The Jackson library offers robust parsing and serialization capabilities for working with JSON data. As always, we need first to add the dependency for the Jackson library:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>${jackson.version}</version>
</dependency>

To map a JSON string, we use the ObjectMapper class, which provides the generic readValue() method and returns the resulting typed Map:

fun jsonStringToMapWithJackson(json: String): Map<String, Any> {
    val objectMapper = jacksonObjectMapper()
    return objectMapper.readValue<Map<String, Any>>(json)
}

6. Conclusion

In this article, we’ve explored how to convert a JSON string into a Map in Kotlin using the Kotlin extension library and three popular JSON libraries: org.json, Jackson, and Gson. All these libraries provide powerful and efficient parsing mechanisms, making them a great choice for working with JSON data.

As always, the complete code for this article is available over on GitHub.