Formatting and Beautifying JSON - potatoscript/json GitHub Wiki

Welcome to the JSON Formatting and Beautifying tutorial, where we transform your messy JSON into clean, human-readable formats! 🧹✨ Let’s dive into why formatting and beautifying JSON is important and how you can do it in Java!

JSON Beautification refers to the process of making JSON data more readable by:

• Adding indentations to show structure.
• Using line breaks to separate objects or arrays.
• Ensuring consistent spacing between keys and values.

When working with JSON, especially in large projects or APIs, the data might look like this:

{"name":"Lucy Berry","age":26,"address":{"city":"Fukuoka","postal_code":"810-0011"}}

Not easy to read, right? 😕
Beautifying it will turn it into something like this:

{
  "name": "Lucy Berry",
  "age": 26,
  "address": {
    "city": "Fukuoka",
    "postal_code": "810-0011"
  }
}

Now, it’s much easier to understand! 💖

Let’s start by using Java to format your JSON data! We’ll be using Jackson and Gson libraries, two popular choices in the Java ecosystem for working with JSON.

If you don't have Jackson in your project yet, add it to your pom.xml file:

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

import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonBeautifyExample {
    public static void main(String[] args) {
        String json = "{\"name\":\"Lucy Berry\",\"age\":26,\"address\":{\"city\":\"Fukuoka\",\"postal_code\":\"810-0011\"}}";
        
        ObjectMapper objectMapper = new ObjectMapper();
        
        try {
            // Beautifying the JSON string with pretty-printing
            String formattedJson = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(objectMapper.readTree(json));
            
            // Displaying the formatted (beautified) JSON
            System.out.println(formattedJson);
        } catch (Exception e) {
            System.out.println("❌ Error: " + e.getMessage());
        }
    }
}

✅ Explanation:

• writerWithDefaultPrettyPrinter() converts your JSON into a nicely formatted string.
• It automatically adds indentations, line breaks, and spaces for better readability.

For Gson, add it to your pom.xml:

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

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class GsonBeautifyExample {
    public static void main(String[] args) {
        String json = "{\"name\":\"Lucy Berry\",\"age\":26,\"address\":{\"city\":\"Fukuoka\",\"postal_code\":\"810-0011\"}}";
        
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        
        // Beautifying JSON string
        String formattedJson = gson.toJson(new com.google.gson.JsonParser().parse(json));
        
        // Displaying the beautified JSON
        System.out.println(formattedJson);
    }
}

✅ Explanation:

• setPrettyPrinting() ensures that the output is formatted with indentations and line breaks.
• Gson makes it simple to convert a JSON string into a pretty-printed format.

If you want to format JSON without libraries, you can manually add indentation and newlines using a text editor. However, it’s not as efficient for large projects, so libraries like Jackson or Gson are highly recommended.

For a quick and easy solution, here are some online tools you can use to beautify JSON without writing any code!

• JSON Formatter & Validator: Paste your raw JSON, and the tool will format it.
• JSONLint: A fast JSON validator and beautifier.
• JSON Editor Online: Great for editing and viewing your JSON data in a formatted way.

These tools are super handy if you just need to quickly clean up some JSON data!

Here are a few best practices for working with JSON formatting:

1. Consistency: Ensure your JSON structure is consistent throughout your project. This means using the same indentation (spaces vs. tabs) and similar key names across your data.
2. Use Libraries for Big Projects: While manual formatting works for small JSON, use libraries (like Jackson or Gson) for bigger projects to ensure efficiency and accuracy.
3. Avoid Unnecessary Whitespaces: In production environments or when sending data over APIs, avoid unnecessary whitespace in JSON. Use compact, minified JSON for performance.

Here’s how JSON looks before and after formatting:

{"name":"Lucy","age":26,"address":{"city":"Fukuoka","postal_code":"810-0011"}}

{
  "name": "Lucy",
  "age": 26,
  "address": {
    "city": "Fukuoka",
    "postal_code": "810-0011"
  }
}

Which version is easier to understand? 🎯

When sending data over APIs or storing data, minified JSON is often preferred because it’s smaller and more efficient. Minified JSON removes all unnecessary spaces and line breaks.

{"name":"Lucy","age":26,"address":{"city":"Fukuoka","postal_code":"810-0011"}}

It’s compact but harder to read. 🧐 You can minify JSON in Jackson or Gson by using their built-in features.