How to Parse JSON in Java

By the end of this page, you will understand how JSON is structured, how to parse JSON in Java, and how to extract values from nested objects and arrays. You will also see practical examples using a common Java JSON library and learn the mistakes beginners often make.

JSON stands for JavaScript Object Notation. It is a text format used to store and exchange structured data.

In Java, JSON is not built into the language in the same way as primitive types or collections, so you usually use a library to parse it. Common choices include:

• org.json
• Gson
• Jackson

The core idea is simple:

• A JSON object maps to key-value pairs.
• A JSON array holds a list of values.
• Values can be strings, numbers, booleans, arrays, objects, or null.

In your JSON:

• pageInfo is a nested object.
• posts is an array.
• The first item inside posts is another object.

This matters in real programming because APIs often return JSON. If your Java application consumes web services, reads configuration files, or processes structured data, you need to know how to:

• parse JSON text
• navigate nested structures
• safely extract values
• loop through arrays of objects

A beginner-friendly way to learn this is to first parse JSON into an object model, then access fields by key.

Think of JSON like a set of boxes and lists:

• A JSON object is like a labeled storage cabinet.
  • Each label is a key like pageName.
  • Each drawer contains a value.
• A JSON array is like a numbered list.
  • You access items by position: first, second, third.

For your JSON:

• The outer object is the main cabinet.
• Inside it, pageInfo is a smaller cabinet.
• posts is a list.
• Each item in posts is another cabinet containing post details.

So parsing JSON in Java means:

1. Open the main cabinet.
2. Find the pageInfo drawer and read values from it.
3. Find the posts list.
4. Open the first post and read fields like post_id.

If you remember object = keys and array = indexes, JSON becomes much easier to navigate.

A common beginner-friendly approach in Java is to use the org.json library.

Core syntax

JSONObject root = new JSONObject(jsonText);
JSONObject pageInfo = root.getJSONObject("pageInfo");
String pageName = pageInfo.getString("pageName");

JSONArray posts = root.getJSONArray("posts");
JSONObject firstPost = posts.getJSONObject(0);
String postId = firstPost.getString("post_id");

Full example

import org.json.JSONArray;
import org.json.JSONObject;

public class JsonExample {
    public static void main(String[] args) {
        String jsonText = """
        {
          "pageInfo": {
            "pageName": "abc",
            "pagePic": "http://example.com/content.jpg"
          },
          "posts": [
            {
              "post_id": "123456789012_123456789012",
              "actor_id": "1234567890",
              "picOfPersonWhoPosted": "http://example.com/photo.jpg",
              "nameOfPersonWhoPosted": "Jane Doe",
              "message": "Sounds cool. Can't wait to see it!",
              "likesCount": "2",
              "comments": [],
              "timeOfPost": "1234567890"
            }
          ]
        }
        """;

        JSONObject root = new JSONObject(jsonText);

        JSONObject pageInfo = root.getJSONObject("pageInfo");
        String pageName = pageInfo.getString("pageName");
        String pagePic = pageInfo.getString("pagePic");

        JSONArray posts = root.getJSONArray("posts");
        JSONObject firstPost = posts.getJSONObject(0);

        String postId = firstPost.getString("post_id");
        String actorId = firstPost.getString("actor_id");
        String message = firstPost.getString("message");

        System.out.println("pageName: " + pageName);
        System.out.println("pagePic: " + pagePic);
        System.out.println("post_id: " + postId);
        System.out.println("actor_id: " + actorId);
        System.out.println("message: " + message);
    }
}

What this example shows

• new JSONObject(jsonText) parses the full JSON string.
• getJSONObject("pageInfo") accesses the nested object.
• getJSONArray("posts") accesses the array.
• getJSONObject(0) gets the first post from the array.
• getString(...) reads string values from JSON objects.

If you expect multiple posts, you should loop through the array instead of reading only index 0.

Consider this shorter example:

String json = """
{
  "pageInfo": {
    "pageName": "abc"
  },
  "posts": [
    {
      "post_id": "123",
      "message": "Hello"
    }
  ]
}
""";

JSONObject root = new JSONObject(json);
JSONObject pageInfo = root.getJSONObject("pageInfo");
String pageName = pageInfo.getString("pageName");
JSONArray posts = root.getJSONArray("posts");
JSONObject firstPost = posts.getJSONObject(0);
String postId = firstPost.getString("post_id");

Step by step

1. String json = ...

   • Stores the raw JSON text.

2. JSONObject root = new JSONObject(json);

   • Parses the text into a Java object representing the outer JSON object.

3. JSONObject pageInfo = root.getJSONObject("pageInfo");

   • Looks up the key pageInfo.
   • The value is another JSON object.

4. String pageName = pageInfo.getString("pageName");

   • Reads the pageName field from the nested object.
   • Result: "abc"

5. JSONArray posts = root.getJSONArray("posts");

   • Looks up the key posts.
   • The value is an array.

6. JSONObject firstPost = posts.getJSONObject(0);

   • Gets the first object in the array.

7. String postId = firstPost.getString("post_id");

   • Reads the post_id field from the first post.
   • Result: "123"

Final values

• pageName → abc
• postId → 123

This is the basic pattern you will use again and again:

• parse root object
• get nested object or array
• access values by key or index

Parsing JSON in Java is used in many common situations:

API responses

A Java application may call a REST API and receive JSON like:

• user profiles
• blog posts
• product data
• payment results

You parse the response to extract fields your app needs.

Configuration files

Some Java programs load JSON configuration such as:

• app settings
• feature flags
• environment-specific values

Data import scripts

You may read JSON files and convert them into:

• database records
• CSV reports
• Java objects

Logging and event processing

Systems often store events as JSON, such as:

• audit logs
• analytics events
• webhook payloads

Mobile and web backends

Java backends frequently receive JSON from clients and send JSON back in responses.

Your example is similar to data returned by a social or content API, where one object contains page metadata and a list of posts.

In real projects, developers usually do more than just call getString() repeatedly.

Common patterns

Validation before reading

Developers often check whether keys exist before accessing them.

if (root.has("pageInfo")) {
    JSONObject pageInfo = root.getJSONObject("pageInfo");
}

Safer optional access

Some libraries provide optional methods such as optString() to avoid exceptions when a key is missing.

String pageName = pageInfo.optString("pageName", "");

Looping through arrays

Real API responses often contain many items.

JSONArray posts = root.getJSONArray("posts");
for (int i = 0; i < posts.length(); i++) {
    JSONObject post = posts.getJSONObject(i);
    System.out.println(post.getString("post_id"));
}

Mapping to Java classes

In larger codebases, developers often use Gson or Jackson to convert JSON directly into Java classes instead of manually reading each key.

Guard clauses

Developers may return early if important data is missing.

if (!root.has("posts")) {
    return;
}

Error handling

Parsing can fail if JSON is invalid, so production code often uses try-catch.

try {
    JSONObject root = new JSONObject(jsonText);
} catch (Exception e) {
    System.out.println("Invalid JSON: " + e.getMessage());
}

These patterns make JSON parsing safer and easier to maintain.

1. Treating an array like an object

Broken code:

JSONObject posts = root.getJSONObject("posts");

Why it is wrong:

• posts is a JSON array, not an object.

Correct code:

JSONArray posts = root.getJSONArray("posts");

2. Forgetting to access an array item by index

Broken code:

String postId = posts.getString("post_id");

Why it is wrong:

• Arrays use numeric indexes.
• You must first get an object from the array.

Correct code:

JSONObject firstPost = posts.getJSONObject(0);
String postId = firstPost.getString("post_id");

3. Assuming a key always exists

Broken code:

String pageName = pageInfo.getString("pageTitle");

Why it is wrong:

• The actual key is pageName, not pageTitle.
• A missing key can cause an exception.

Better approach:

String pageName = pageInfo.optString("pageName", "Unknown");

4. Ignoring empty arrays

Broken code:

JSONObject firstPost = posts.getJSONObject(0);

Why it can fail:

• If posts is empty, index 0 does not exist.

Safer version:

if (posts.length() > 0) {
    JSONObject firstPost = posts.getJSONObject(0);
}

5. Confusing JSON strings with Java objects

A JSON string is plain text until you parse it.

Broken idea:

• Trying to use JSON keys directly on a String

Correct idea:

• Parse the string first into JSONObject or map it to a Java class.

6. Not handling invalid JSON

If the JSON text is malformed, parsing will fail. Wrap parsing logic in try-catch when reading external input.

Manual JSON access vs mapping to Java classes

JSON object vs JSON array

getString() vs safer optional access

org.json vs Gson vs Jackson

JSON parsing basics in Java

JSONObject root = new JSONObject(jsonText);

Read a nested object

JSONObject pageInfo = root.getJSONObject("pageInfo");
String pageName = pageInfo.getString("pageName");
String pagePic = pageInfo.getString("pagePic");

Read an array

JSONArray posts = root.getJSONArray("posts");

Read the first object in an array

JSONObject firstPost = posts.getJSONObject(0);
String postId = firstPost.getString("post_id");

Loop through an array

for (int i = 0; i < posts.length(); i++) {
    JSONObject post = posts.getJSONObject(i);
    System.out.println(post.getString("post_id"));
}

Safer access

String value = object.optString("key", "default");

Rules to remember

• Object → access by key
• Array → access by index
• Parse JSON text before reading values
• Check array length before using index 0
• Use optional access if fields may be missing

Common edge cases

• Missing keys
• Empty arrays
• Invalid JSON text
• Wrong type for a field
• Numeric values stored as strings

How do I parse JSON in Java?

Use a JSON library such as org.json, Gson, or Jackson. Parse the JSON string into an object, then access nested objects and arrays.

How do I get a value from a nested JSON object in Java?

First get the nested object, then read its field:

JSONObject pageInfo = root.getJSONObject("pageInfo");
String pageName = pageInfo.getString("pageName");

How do I read a JSON array in Java?

Use getJSONArray(), then access items by index:

JSONArray posts = root.getJSONArray("posts");
JSONObject firstPost = posts.getJSONObject(0);

What happens if a JSON key does not exist?

Methods like getString() usually throw an exception. Safer methods like optString() return a default value instead.

Which Java JSON library should beginners use?

org.json is easy for learning manual parsing. Gson and Jackson are often better for larger applications.

Can I convert JSON directly into Java classes?

Yes. Libraries such as Gson and Jackson can map JSON fields directly to Java objects, which is common in real projects.

Why is my JSON parsing code failing on arrays?

A common reason is treating an array like an object. If a key contains [...], use JSONArray, not JSONObject.

• JSON objects — Related because parsing starts with understanding key-value structures.
• JSON arrays — Related because many API responses contain lists of items.
• Nested data structures — Related because JSON often contains objects inside objects and arrays.
• Java collections — Related because parsed JSON data is often moved into lists and maps.
• Exception handling in Java — Related because parsing invalid or missing data can throw errors.
• Gson — Related because it is a popular library for converting JSON into Java objects.
• Jackson — Related because it is widely used in production Java applications for JSON processing.
• REST APIs — Related because JSON is the most common format returned by APIs.