Java写深层的嵌套JSON字符串以及嵌套JSON字符串解析

要在Java中编写深层嵌套的JSON字符串，可以使用任何一个流行的JSON库，如Jackson、Gson或JSON-java
以下是示例，演示如何编写一个具有深层嵌套的JSON字符串：

1. 使用 JSON-Java

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

public class NestedJsonExample {
    public static void main(String[] args) {
        /**
         * 1.JSONObject and JSONArray
         */
        JSONObject outerObject = new JSONObject();

        // 添加简单属性
        outerObject.put("name", "John Doe");
        outerObject.put("age", 30);

        // 嵌套的JSON对象 --> 将addressObject对象作为 outerObject 对象的“address”属性。
        JSONObject addressObject = new JSONObject();
        addressObject.put("street", "123 Main St");
        addressObject.put("city", "New York");
        addressObject.put("state", "NY");
        outerObject.put("address", addressObject);

        // 嵌套的JSON数组 --> 将 hobbiesArray 数组作为 outerObject 对象的“hobbies”属性。
        JSONArray hobbiesArray = new JSONArray();
        hobbiesArray.put("Reading");
        hobbiesArray.put("Music");
        hobbiesArray.put("Sports");
        outerObject.put("hobbies", hobbiesArray);

        // 输出JSON字符串
        String jsonString = outerObject.toString();
        System.out.println(jsonString);
    }
}

/**
 * 在上述示例中，我们创建了一个JSONObject，命名为outerObject，
 * 并将各种属性和嵌套的JSON对象（addressObject）以及嵌套的JSON数组（hobbiesArray）添加到outerObject中。
 * 最后，我们将outerObject转换为字符串，并将其打印出来。
 */

运行以上代码将输出如下JSON字符串：

{
    "name": "John Doe",
    "age": 30,
    "address": {
        "street": "123 Main St",
        "city": "New York",
        "state": "NY"
    },
    "hobbies": [
        "Reading",
        "Music",
        "Sports"
    ]
}

2. 使用 Jackson

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) {
        try {
            // 创建一个ObjectMapper对象，用于将Java对象序列化为JSON字符串
            ObjectMapper mapper = new ObjectMapper();

            // 创建嵌套的JSON对象层次结构
            ObjectNode root = mapper.createObjectNode();
            ObjectNode addressNode = mapper.createObjectNode();
            ArrayNode detailsNode = mapper.createArrayNode();

	        // 添加数据到JSON对象中
	        detailsNode.add("John Doe");
	        detailsNode.add( 30);
            addressNode.put("street", "123 Main St");
            addressNode.put("city", "New York");

            root.set("details", detailsNode);
            root.set("address", addressNode);

            // 将JSON对象转换为字符串
            //  writerWithDefaultPrettyPrinter() ,它会添加缩进和换行符，使用默认的漂亮打印机（pretty printer），使生成的JSON字符串更易读.简而言之美化代码。
            String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(root);
            System.out.println(jsonString);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

运行以上代码将输出如下JSON字符串：

{
  "details" : [ "John Doe", 30 ],
  "address" : {
    "street" : "123 Main St",
    "city" : "New York"
  }
}

3.Gson

在Java中不确定JSON结构的情况下解析多层嵌套的JSON字符串，可以使用Gson库的JsonElement和JsonObject进行动态解析

import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;

public class GsonExample {
    public static void main(String[] args) {
        String jsonString = "{\"name\":\"John\",\"age\":30,\"address\":{\"street\":\"123 Main St\",\"city\":\"New York\",\"state\":\"NY\"}}";

        Gson gson = new Gson();
        JsonElement jsonElement = gson.fromJson(jsonString, JsonElement.class);

        if (jsonElement.isJsonObject()) {
            JsonObject jsonObject = jsonElement.getAsJsonObject();

            // 解析顶层属性
            if (jsonObject.has("name")) {
                String name = jsonObject.get("name").getAsString();
                System.out.println("Name: " + name);
            }

            if (jsonObject.has("age")) {
                int age = jsonObject.get("age").getAsInt();
                System.out.println("Age: " + age);
            }

            // 解析嵌套属性
            if (jsonObject.has("address")) {
                JsonObject addressObject = jsonObject.get("address").getAsJsonObject();
                if (addressObject.has("street")) {
                    String street = addressObject.get("street").getAsString();
                    System.out.println("Street: " + street);
                }
                if (addressObject.has("city")) {
                    String city = addressObject.get("city").getAsString();
                    System.out.println("City: " + city);
                }
                if (addressObject.has("state")) {
                    String state = addressObject.get("state").getAsString();
                    System.out.println("State: " + state);
                }
            }
        }
    }
}

解释：首先将JSON字符串解析为JsonElement对象。然后，使用isJsonObject()方法检查JSON元素是否为一个对象。如果是对象，我们可以使用getAsJsonObject()获取JsonObject实例。

然后，根据知道的属性名使用has()方法检查该属性是否存在，然后使用get()方法获取属性的值并进行相应的处理。对于嵌套的属性，我们可以继续使用相同的模式进行解析。

这种方法可以在不知道JSON结构的情况下进行灵活的解析，并根据需要提取所需的数据。

打印结果：

Name: John
Age: 30
Street: 123 Main St
City: New York
State: NY