Efficiently parse nested object data in JSON arrays in Java

This tutorial details how to parse a JSON array containing nested JSON objects in Java to extract specific fields like 'id' and 'result'. The article will demonstrate two main methods: traditional loop iteration combined with POJO/Record, and the use of Java Stream API for more concise functional processing, aiming to help developers process complex JSON responses efficiently and robustly.

In modern application development, data interaction with servers is the norm, and JSON is widely used as a lightweight data exchange format. We often encounter JSON responses returned by the server that contain nested arrays and object structures, such as:

 {"result":[{"result":"success","id":"345"}]}

In this structure, our goal is to extract the "result" and "id" values ​​in each child object from the JSON array corresponding to the "result" key. After directly obtaining the entire JSONArray, further processing is required to access the internal key-value pairs. This tutorial will introduce two efficient ways to achieve this in Java.

Method 1: Use POJO/Record combined with loop iterative analysis

When the JSON structure is relatively fixed, defining a corresponding Java object (Plain Old Java Object, POJO) or Java 16 Record can greatly improve the readability and type safety of the code. We map each internal object in JSON to a Java Record.

First, define a Record to represent each element in the JSON array:

 public record Result(String result, int id) {}

This Result Record contains two fields: result (string type) and id (integer type), which correspond to the key-value pairs in the JSON sub-object.

Next, we will use the org.json library to parse the JSON string and extract the data through loop iteration:

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

import java.util.ArrayList;
import java.util.List;

public class JsonParsingExample {

    public record Result(String result, int id) {} ​​// Nested Record definition or separate file public static void main(String[] args) {
        String response = """
            {"result":[{"result":"success","id":"345"}]}
        """;

        try {
            // 1. Parse the entire response string into JSONObject
            JSONObject jsonResponse = new JSONObject(response);

            // 2. Get the JSONArray with the key "result"
            JSONArray jsonArray = jsonResponse.getJSONArray("result");

            // 3. Create a List to store the parsed Result object List results = new ArrayList();

            // 4. Traverse JSONArray and parse each JSONObject
            for (int i = 0; i 
 Output:
 Result[result=success, id=345]
 Things to note:

 The org.json library provides methods such as getString() and getInt() to safely obtain key values ​​of specified types. These methods throw JSONException if the key does not exist or the type does not match.
 In order to enhance robustness, you can use opt series methods such as optString(key, defaultValue) or optInt(key, defaultValue), which return the default value when the key does not exist instead of throwing an exception.
 Make sure you have added the dependency of the org.json library to your project, for example in Maven:
 <dependency>
    <groupid>org.json</groupid>
    <artifactid>json</artifactid>
    <version>20231013</version>
</dependency>


 Method 2: Use Java Stream API to parse
 The Stream API introduced in Java 8 provides a more functional and concise way to handle collection data. For processing JSONArray, we can convert it to a stream and then use stream operations to convert it.
 import org.json.JSONArray;
import org.json.JSONObject;

import java.util.List;
import java.util.stream.StreamSupport; // Pay attention to importing this package public class JsonStreamParsingExample {

    public record Result(String result, int id) {} ​​// Nested Record definition or separate file public static void main(String[] args) {
        String response = """
            {"result":[{"result":"success","id":"345"}]}
        """;

        try {
            JSONObject jsonResponse = new JSONObject(response);
            JSONArray jsonArray = jsonResponse.getJSONArray("result");

            // Use Stream API to parse JSONArray
            List results = StreamSupport.stream(jsonArray.spliterator(), false) // 1. Convert JSONArray to Stream
 Detailed explanation of analysis steps:

 StreamSupport.stream(jsonArray.spliterator(), false): JSONArray itself is not an Iterable, but it provides a spliterator() method. The StreamSupport.stream() tool class can use this Spliterator to create a Stream

 .map(JSONObject.class::cast): Since the elements in JSONArray are JSONObject, we use the map operation to cast each element in Stream

 .map(jsonObject -> new Result(jsonObject.getString("result"), jsonObject.getInt("id"))): This is the core conversion step. For each JSONObject in the stream, we extract its "result" and "id" fields and construct a new Result object with them.
 .toList(): This is a Java 16 syntactic sugar for collecting all elements in a stream into a new List. If you are using an older version of Java, you should use collect(Collectors.toList()).

 Advantages:

 Code Simplicity: The Stream API can often complete complex data transformations with fewer lines of code.
 Readability: Chained operations make the data conversion process clear at a glance.
 Functional programming: encourages side-effect-free conversion operations and improves code quality.

 Summarize
 This article describes two methods of parsing nested JSON arrays in Java and extracting specific fields:

 Traditional loop iteration combined with POJO/Record: suitable for fine control of the parsing process, or for use in older Java environments. It's intuitive to understand and easy to debug.
 Java Stream API: Provides a more modern and concise functional programming style. It is particularly suitable for complex chain conversions and can effectively reduce boilerplate code.

 Which method to choose depends on project needs, team preference, and Java version. No matter which method you choose, you should pay attention to handling JSONException to ensure the robustness of your program. For more complex JSON structures or scenarios that pursue higher performance, you can consider using third-party JSON processing libraries such as Jackson or Gson, which provide more powerful data binding and serialization/deserialization functions.

The above is the detailed content of Efficiently parse nested object data in JSON arrays in Java. For more information, please follow other related articles on the PHP Chinese website!