Remove Whitespaces From a JSON in Java

1. Introduction

In this tutorial, we’ll explore the process of removing extra whitespaces from JSON data in Java to minify it.

Often we face a situation where we need to minify the provided JSON data for optimized storage, or we need to remove the extra whitespaces so we can compare multiple JSON objects easily.

To achieve this, we’ll leverage the capabilities of the Jackson and Gson libraries, which will be helpful in removing whitespaces from the provided JSON data.

2. Remove Whitespaces Using Custom Logic

JSON data is typically structured with colons (“:”) to separate keys from values and commas (“,”) to separate key-value pairs. Given that JSON keys are enclosed in quotes (‘”‘) and JSON strings use escape sequences, we can implement a logic that reads the character one by one and constructs the JSON string without any extra whitespace.

By carefully processing the characters while considering the quoted sections and escape sequences, we can ensure a clean and correctly formatted JSON output:

public String removeExtraWhiteSpaces(String jsonString) {
    StringBuilder result = new StringBuilder(json.length());
    boolean inQuotes = false;
    boolean escapeMode = false;
    for (char character : json.toCharArray()) {
        if (escapeMode) {
            result.append(character);
            escapeMode = false;
        } else if (character == '"') {
            inQuotes = !inQuotes;
            result.append(character);
        } else if (character == '\\') {
            escapeMode = true;
            result.append(character);
        } else if (!inQuotes && character == ' ') {
            continue;
        } else {
            result.append(character);
        }
    }
    return result.toString();
}

Let’s consider we’ve got the following JSON string defined as the inputJson variable:

{
    "name" : "John",
    "address" : "New       York",
    "age" : 30,
    "phoneNumber" : 9999999999
}

And we want the result JSON string (defined as expectedJson) without extra spaces:

{"name":"John","address":"New       York","age":30,"phoneNumber":9999999999}

Let’s read the inputJson as String and remove whitespaces:

@Test
public void givenWhiteSpaceRemoval_whenJsonContainWhitespaces_thenWhitespaceRemoved() {
    String result = removeExtraWhitespaces(inputJson);
    assertEquals(expectedJson, result); 
}

3. Remove Whitespaces Using Jackson

To remove whitespaces using Jackson, let’s start by adding the following dependency to the pom.xml file:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>

It is highly recommended to consider utilizing the most up-to-date versions available from the Maven central repository for the jackson-databind library.

To remove the extra whitespaces from the JSON string, we’ll use the writeValueAsString() method:

public String removeExtraWhitespacesUsingJackson(String json) {
    ObjectMapper objectMapper = new ObjectMapper();
    JsonNode jsonNode = objectMapper.readTree(json);
    return objectMapper.writeValueAsString(jsonNode); 
}

Let’s consider we’ve got the following JSON string defined as the inputJson variable:

{
    "name" : "John",
    "address" : "New       York",
    "age" : 30,
    "phoneNumber" : 9999999999
}

And we want the result JSON string (defined as expectedJson) without extra spaces:

{"name":"John","address":"New       York","age":30,"phoneNumber":9999999999}

Let’s use the inputJson as String and remove whitespaces:

@Test
public void giveWhiteSpaceRemovalUsingJackson_whenJsonContainWhitespaces_thenWhitespaceRemoved(){
    String result = removeExtraWhitespaceUsingJackson(inputJson);   
    assertEquals(expectedJson, result);
}

4. Remove Whitespaces Using Gson

Let’s first add the Gson Maven dependency:

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.11.0</version>
</dependency>

We encourage you to consistently utilize the most up-to-date versions of the gson library from the Maven central repository.

To remove whitespaces from a JSON string, we need to use a custom JsonSerializer.

We’ll use a custom StringSerializer to trim the whitespaces from JSON string values. By registering this serializer with GsonBuilder, Gson will apply the custom serialization logic for strings, effectively removing whitespaces from the values while keeping the structure of the JSON intact:

public String removeWhitespacesUsingGson(String json) {
    Gson gson = new GsonBuilder().registerTypeAdapter(String.class, new StringSerializer()).create();
    JsonElement jsonElement = gson.fromJson(json, JsonElement.class);
    return gson.toJson(jsonElement);
}

class StringSerializer implements JsonSerializer<String> {
    @Override
    public JsonElement serialize(String src, Type typeOfSrc, JsonSerializationContext context) {
        return new JsonPrimitive(src.trim());
    }
}

Let’s take the same JSON string defined as the inputJson variable:

{
    "name" : "John",
    "address" : "New       York",
    "age" : 30,
    "phoneNumber" : 9999999999
}

And to generate the JSON string without extra spaces (defined as expectedJson) :

{"name":"John","address":"New       York","age":30,"phoneNumber":9999999999}

Let’s use the inputJson as String and remove whitespaces:

@Test
public void giveWhitespaceRemovalUsingGson_whenJsonContainsWhitespaces_thenWhitespaceRemoved() {
    String result = removeWhitespacesUsingGson(inputJson);
    assertEquals(expectedJson, result);
}

5. Conclusion

In this article, we have explored various methods for removing extra whitespaces from a JSON string in Java.