Java 8 JSON库的总结、部分案例的详解-蒲公英云

JAVA 8 JSON库总结

在 Java 8 中，没有内置的 JSON 库，但有很多第三方 JSON 库可供使用。这些库提供了解析、生成、转换和操作 JSON 数据的功能。以下是一些流行的第三方 JSON 库：

Jackson：一个高性能的 JSON 处理库，可以将 Java 对象与 JSON 数据进行相互转换。官方网站：GitHub - FasterXML/jackson: Main Portal page for the Jackson project
Gson：Google 提供的一个用于处理 JSON 数据的库，可以轻松将 Java 对象转换为 JSON，反之亦然。官方网站：GitHub - google/gson: A Java serialization/deserialization library to convert Java Objects into JSON and back
Fastjson：Alibaba 开发的一个高性能 JSON 解析器，提供简单易用的 API 来处理 JSON 数据。官方网站：GitHub - alibaba/fastjson: FASTJSON 2.0.x has been released, faster and more secure, recommend you upgrade.
JSON-java（org.json）：一个简单的 JSON 处理库，用于解析和创建 JSON 数据。官方网站：GitHub - stleary/JSON-java: A reference implementation of a JSON package in Java.
JSON.simple：一个简单、轻量级的 JSON 解析和生成库。官方网站：GitHub - fangyidong/json-simple: A simple Java toolkit for JSON. You can use json-simple to encode or decode JSON text.
Genson：一个功能丰富、易用的 JSON 序列化和反序列化库。官方网站：GitHub - owlike/genson: Genson a fast & modular Java <> Json library
Jodd JSON：Jodd 工具集中的 JSON 解析器和生成器。官方网站：https://jodd.org/doc/json.html
Flexjson：一个用于序列化和反序列化 Java 对象为 JSON 的库。官方网站：JSON Serialization Usage
Johnzon：Apache Johnzon 是一个实现了 JSON 处理（JSR-353）规范的库，用于解析和生成 JSON 数据。官方网站：Apache Johnzon – Apache Johnzon
Moshi：Square 公司开发的一个现代、快速的 JSON 库，用于将 Java 对象与 JSON 进行互相转换。官方网站：GitHub - square/moshi: A modern JSON library for Kotlin and Java.

这些库各有特点，你可以根据项目需求和个人喜好选择合适的库。在 Java 9 及更高版本中，也可以使用 Java 内置的 JSON-P (javax.json) 和 JSON-B (javax.json.bind) 处理 JSON 数据。

JAVA 8 JSON 第三方库值 Fastjson 部分案例详解

1.JSON 字符串解析为 JSONObject，并将其转换为 Map

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSON;
import java.util.Map;
public class ToMapExample {
    public static void main(String[] args) {
        // 示例的JSON字符串
        String jsonString = "{\"a\": 1, \"b\": \"value\", \"c\": true}";
        // 将JSON字符串解析为JSONObject
        JSONObject jsonObject = JSON.parseObject(jsonString);
        // 将JSONObject转换为Map<String, Object>
        Map<String, Object> resultMap = jsonObject;
        // 输出转换后的Map
        System.out.println(resultMap);
    }
}

这段代码是 Java 中一个简单的示例，用于将 JSON 字符串解析为 JSONObject，并将其转换为 Map。以下是对每一行的详细解释：

public static void main(String[] args) {：这是 Java 程序的入口点，main 方法。当你运行 Java 程序时，它从这里开始执行。
// 示例的JSON字符串：这是一条注释，说明接下来的代码是一个示例 JSON 字符串。
String jsonString = "{\"a\": 1, \"b\": \"value\", \"c\": true}";：这行代码声明了一个 String 类型的变量 jsonString，存储了一个 JSON 字符串。JSON 字符串中包含三个键值对，键 “a” 的值是整数 1，键 “b” 的值是字符串 “value”，键 “c” 的值是布尔值 true。
// 将JSON字符串解析为JSONObject：这是一条注释，说明接下来的代码将 JSON 字符串解析为 JSONObject。
JSONObject jsonObject = JSON.parseObject(jsonString);：这行代码调用 JSON 类的 parseObject 方法，将 jsonString 中的 JSON 字符串解析为一个 JSONObject 类型的对象 jsonObject。
// 将JSONObject转换为Map<String, Object>：这是一条注释，说明接下来的代码将 JSONObject 转换为 Map。
Map<String, Object> resultMap = jsonObject;：这行代码将 jsonObject 赋值给一个 Map 类型的变量 resultMap。实际上，JSONObject 类已经实现了 Map 接口，因此可以直接将 JSONObject 作为 Map 使用。
// 输出转换后的Map：这是一条注释，说明接下来的代码将输出转换后的 Map。
System.out.println(resultMap);：这行代码使用 System.out.println 方法输出 resultMap。输出的内容将是 JSON 字符串中的键值对，例如：{a=1, b=value, c=true}。
}：这是 main 方法的结束括号。

需要注意的是，这段代码使用了 JSONObject 和 JSON 类，它们通常来自第三方 JSON 库，如 Alibaba 的 fastjson。要使这段代码能够运行，你需要在项目中添加 fastjson 库作为依赖。

2. JSON 字符串解析为 JSONObject，并直接使用 JSONObject 作为 Map

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSON;
public class FastJsonExample {
    public static void main(String[] args) {
        // 示例的JSON字符串
        String jsonString = "{\"a\": 1, \"b\": \"value\", \"c\": true}";
        // 将JSON字符串解析为JSONObject
        JSONObject jsonObject = JSON.parseObject(jsonString);
        // 直接使用JSONObject作为Map
        System.out.println("Key 'a' value: " + jsonObject.get("a"));
        System.out.println("Key 'b' value: " + jsonObject.get("b"));
        System.out.println("Key 'c' value: " + jsonObject.get("c"));
        // 遍历JSONObject的键
        for (String key : jsonObject.keySet()) {
            System.out.println("Key: " + key + ", Value: " + jsonObject.get(key));
        }
    }
}

这段代码是一个 Java 程序示例，用于将 JSON 字符串解析为 JSONObject，并直接使用 JSONObject 作为 Map。以下是对每一行的详细解释：

public static void main(String[] args) {：这是 Java 程序的入口点，main 方法。当你运行 Java 程序时，它从这里开始执行。
// 示例的JSON字符串：这是一条注释，说明接下来的代码是一个示例 JSON 字符串。
String jsonString = "{\"a\": 1, \"b\": \"value\", \"c\": true}";：这行代码声明了一个 String 类型的变量 jsonString，存储了一个 JSON 字符串。JSON 字符串中包含三个键值对，键 “a” 的值是整数 1，键 “b” 的值是字符串 “value”，键 “c” 的值是布尔值 true。
// 将JSON字符串解析为JSONObject：这是一条注释，说明接下来的代码将 JSON 字符串解析为 JSONObject。
JSONObject jsonObject = JSON.parseObject(jsonString);：这行代码调用 JSON 类的 parseObject 方法，将 jsonString 中的 JSON 字符串解析为一个 JSONObject 类型的对象 jsonObject。
// 直接使用JSONObject作为Map：这是一条注释，说明接下来的代码将直接使用 JSONObject 作为 Map。

7-9. System.out.println("Key 'a' value: " + jsonObject.get("a"));，System.out.println("Key 'b' value: " + jsonObject.get("b"));，System.out.println("Key 'c' value: " + jsonObject.get("c"));：这三行代码使用 System.out.println 方法分别输出键 “a”、”b” 和 “c” 对应的值。由于 JSONObject 实现了 Map 接口，你可以直接使用 get 方法获取键对应的值。

10.// 遍历JSONObject的键：这是一条注释，说明接下来的代码将遍历 JSONObject 中的键。

11.for (String key : jsonObject.keySet()) {：这行代码是一个 for-each 循环，用于遍历 jsonObject 的键。jsonObject.keySet() 方法返回一个包含所有键的 Set 集合。

12.System.out.println("Key: " + key + ", Value: " + jsonObject.get(key));：这行代码使用 System.out.println 方法输出当前遍历到的键和对应的值。

13.}：这是 for-each 循环的结束括号。

14.}：这是 main 方法的结束括号。

3.解析 JSON 字符串并从中提取 JSONArray

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
public class FastJsonExample {
    public static void main(String[] args) {
        // 示例的JSON字符串
        String jsonString = "{\"a\": 1, \"b\": \"value\", \"c\": true, \"trueDepOrder\": [1, 2, 3]}";
        // 将JSON字符串解析为JSONObject
        JSONObject jsonObject = JSON.parseObject(jsonString);
        // 获取JSONArray，如果不存在，则返回一个新的空JSONArray
        JSONArray trueDepOrder = jsonObject.containsKey("trueDepOrder") ? jsonObject.getJSONArray("trueDepOrder") : new JSONArray();
        // 输出获取到的JSONArray
        System.out.println(trueDepOrder);
    }
}

这段代码是一个 Java 程序示例，用于解析 JSON 字符串并从中提取 JSONArray。以下是对每一行的详细解释：

public class FastJsonExample {：这行代码定义了一个名为 FastJsonExample 的公共类。这个类包含 main 方法，用于运行示例。
public static void main(String[] args) {：这是 Java 程序的入口点，main 方法。当你运行 Java 程序时，它从这里开始执行。
// 示例的JSON字符串：这是一条注释，说明接下来的代码是一个示例 JSON 字符串。
String jsonString = "{\"a\": 1, \"b\": \"value\", \"c\": true, \"trueDepOrder\": [1, 2, 3]}";：这行代码声明了一个 String 类型的变量 jsonString，存储了一个 JSON 字符串。JSON 字符串中包含四个键值对，键 “a” 的值是整数 1，键 “b” 的值是字符串 “value”，键 “c” 的值是布尔值 true，键 “trueDepOrder” 的值是一个包含三个整数的 JSON 数组。
// 将JSON字符串解析为JSONObject：这是一条注释，说明接下来的代码将 JSON 字符串解析为 JSONObject。
JSONObject jsonObject = JSON.parseObject(jsonString);：这行代码调用 JSON 类的 parseObject 方法，将 jsonString 中的 JSON 字符串解析为一个 JSONObject 类型的对象 jsonObject。
// 获取JSONArray，如果不存在，则返回一个新的空JSONArray：这是一条注释，说明接下来的代码将从 jsonObject 中获取名为 “trueDepOrder” 的 JSONArray，如果不存在，则返回一个新的空 JSONArray。
JSONArray trueDepOrder = jsonObject.containsKey("trueDepOrder") ? jsonObject.getJSONArray("trueDepOrder") : new JSONArray();：这行代码使用三元运算符检查 jsonObject 是否包含键 “trueDepOrder”。如果包含，则调用 jsonObject.getJSONArray 方法获取对应的 JSONArray；如果不包含，则创建一个新的空 JSONArray。结果将赋值给名为 trueDepOrder 的 JSONArray 变量。
// 输出获取到的JSONArray：这是一条注释，说明接下来的代码将输出获取到的 JSONArray。
System.out.println(trueDepOrder);：这行代码使用 System.out.println 方法输出 trueDepOrder 变量。输出的内容将是 JSON 字符串中 “trueDepOrder” 对应的 JSON 数组，例如：[1, 2, 3]。
}：这是 main 方法的结束括号。
}：这是 FastJsonExample 类的结束括号。

需要注意的是，这段代码使用了 JSONObject、JSON 和 JSONArray 类，它们通常来自第三方 JSON 库，如 Alibaba 的 fastjson。要使这段代码能够运行，你需要在项目中添加 fastjson 库作为依赖。

4.解析 JSON 字符串，向 JSON 数组中添加一个新的 JSONObject，并输出更新后的 JSONObject

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
public class FastJsonExample {
    public static void main(String[] args) {
        // 示例的JSON字符串
        String jsonString = "{\"departmentIdList\": []}";
        // 将JSON字符串解析为JSONObject
        JSONObject jsonObject = JSON.parseObject(jsonString);
        // 用于演示的代码，实际项目中使用你自己的实现
        JSONObject enterpriseServiceResult = JSON.parseObject("{\"departmentId\": \"exampleId\"}");
        // 向departmentIdList中添加一个新的JSONObject
        JSONArray departmentIdList = jsonObject.getJSONArray("departmentIdList");
        departmentIdList.add(
            new JSONObject().put("AUDITDEPARTMENTID", enterpriseServiceResult.getString("departmentId"))
        );
        // 输出更新后的JSONObject
        System.out.println(jsonObject);
    }
}

这段代码是一个 Java 程序示例，用于解析 JSON 字符串，向 JSON 数组中添加一个新的 JSONObject，并输出更新后的 JSONObject。以下是对每一行的详细解释：

public static void main(String[] args) {：这是 Java 程序的入口点，main 方法。当你运行 Java 程序时，它从这里开始执行。
// 示例的JSON字符串：这是一条注释，说明接下来的代码是一个示例 JSON 字符串。
String jsonString = "{\"departmentIdList\": []}";：这行代码声明了一个 String 类型的变量 jsonString，存储了一个 JSON 字符串。JSON 字符串中包含一个键 “departmentIdList”，其值是一个空的 JSON 数组。
// 将JSON字符串解析为JSONObject：这是一条注释，说明接下来的代码将 JSON 字符串解析为 JSONObject。
JSONObject jsonObject = JSON.parseObject(jsonString);：这行代码调用 JSON 类的 parseObject 方法，将 jsonString 中的 JSON 字符串解析为一个 JSONObject 类型的对象 jsonObject。
// 用于演示的代码，实际项目中使用你自己的实现：这是一条注释，说明接下来的代码是用于演示的，实际项目中你需要使用自己的实现。
JSONObject enterpriseServiceResult = JSON.parseObject("{\"departmentId\": \"exampleId\"}");：这行代码调用 JSON 类的 parseObject 方法，将一个包含键 “departmentId” 的 JSON 字符串解析为一个 JSONObject 类型的对象 enterpriseServiceResult。这里的 “exampleId” 只是一个示例值，实际项目中需要替换为真实数据。
// 向departmentIdList中添加一个新的JSONObject：这是一条注释，说明接下来的代码将向名为 “departmentIdList” 的 JSON 数组中添加一个新的 JSONObject。
JSONArray departmentIdList = jsonObject.getJSONArray("departmentIdList");：这行代码调用 jsonObject 的 getJSONArray 方法，获取名为 “departmentIdList” 的 JSON 数组，并将其赋值给一个 JSONArray 类型的变量 departmentIdList。
departmentIdList.add(new JSONObject().put("AUDITDEPARTMENTID", enterpriseServiceResult.getString("departmentId")));：这行代码首先创建了一个新的空 JSONObject，然后使用 put 方法向该 JSONObject 中添加一个键 “AUDITDEPARTMENTID”，其值为 enterpriseServiceResult 中 “departmentId” 对应的字符串。接着，将新创建的 JSONObject 添加到 departmentIdList JSON 数组中。
// 输出更新后的JSONObject：这是一条注释，说明接下来的代码将输出更新后的 JSONObject。
System.out.println(jsonObject);：这行代码使用 System.out.println 方法输出 jsonObject。输出的内容将是更新后的 JSON 字符串，例如：{"departmentIdList": [{"AUDITDEPARTMENTID": "exampleId"}]}。
}：这是 main 方法的结束括号。

需要注意的是，这段代码使用了 JSONObject、JSON 和 JSONArray 类，它们通常来自第三方JSON 库，如 Alibaba 的 fastjson。要使这段代码能够运行，你需要在项目中添加 fastjson 库作为依赖。

这个示例展示了如何操作 JSON 对象和数组。这里的关键点是在已有的 JSON 数组（departmentIdList）中添加一个新的 JSONObject。通过使用 JSONObject 的 put() 方法，我们向新创建的 JSONObject 中添加了一个键值对，然后将其添加到 JSON 数组中。最后，我们打印出了修改后的 jsonObject。

在实际项目中，你可能需要根据实际业务需求修改 JSON 字符串和操作。这个示例展示了如何在 fastjson 中完成这些操作，为你提供了一个基本的参考。

5.org.json与fastjson之间转换

①将 org.json.JSONObject 类型的 JSON 对象转换为 com.alibaba.fastjson.JSONObject 类型的 JSON 对象

public static com.alibaba.fastjson.JSONObject orgJsonToFasterxml(org.json.JSONObject orgJson) {
        String jsonString = orgJson.toString();
        com.alibaba.fastjson.JSONObject fastJson = com.alibaba.fastjson.JSON.parseObject(jsonString);
        return fastJson;
    }

这段代码是一个 Java 方法，用于将 org.json.JSONObject 类型的 JSON 对象转换为 com.alibaba.fastjson.JSONObject 类型的 JSON 对象。以下是对每一行的详细解释：

public static com.alibaba.fastjson.JSONObject orgJsonToFasterxml(org.json.JSONObject orgJson) {：这行代码定义了一个名为 orgJsonToFasterxml 的公共静态方法。该方法接收一个 org.json.JSONObject 类型的参数 orgJson，并返回一个 com.alibaba.fastjson.JSONObject 类型的对象。
String jsonString = orgJson.toString();：这行代码调用 orgJson 对象的 toString 方法，将 orgJson 对象转换为一个 JSON 字符串，并将其赋值给名为 jsonString 的 String 类型变量。
com.alibaba.fastjson.JSONObject fastJson = com.alibaba.fastjson.JSON.parseObject(jsonString);：这行代码调用 com.alibaba.fastjson.JSON 类的 parseObject 方法，将 jsonString 中的 JSON 字符串解析为一个 com.alibaba.fastjson.JSONObject 类型的对象 fastJson。
return fastJson;：这行代码返回转换后的 com.alibaba.fastjson.JSONObject 类型的对象 fastJson。
}：这是 orgJsonToFasterxml 方法的结束括号。

这个方法的目的是在两个不同的 JSON 库之间进行转换：将 org.json 类型的 JSON 对象转换为 com.alibaba.fastjson 类型的 JSON 对象。这在实际项目中可能会用到，特别是当需要在不同的库之间进行互操作时。

②将 com.alibaba.fastjson.JSONObject 类型的 JSON 对象转换为 org.json.JSONObject 类型的 JSON 对象

public static org.json.JSONObject orgJsonToFasterxml(com.alibaba.fastjson.JSONObject fastJson) {
        String jsonString = fastJson.toJSONString();
        org.json.JSONObject orgJson  = new org.json.JSONObject(jsonString);
        return orgJson;
    }

这段代码是一个 Java 方法，用于将 com.alibaba.fastjson.JSONObject 类型的 JSON 对象转换为 org.json.JSONObject 类型的 JSON 对象。注意，方法名 orgJsonToFasterxml 应更改为 fastJsonToOrgJson，以便更准确地表示其功能。以下是对每一行的详细解释：

public static org.json.JSONObject orgJsonToFasterxml(com.alibaba.fastjson.JSONObject fastJson) {：这行代码定义了一个名为 orgJsonToFasterxml 的公共静态方法。该方法接收一个 com.alibaba.fastjson.JSONObject 类型的参数 fastJson，并返回一个 org.json.JSONObject 类型的对象。
String jsonString = fastJson.toJSONString();：这行代码调用 fastJson 对象的 toJSONString 方法，将 fastJson 对象转换为一个 JSON 字符串，并将其赋值给名为 jsonString 的 String 类型变量。
org.json.JSONObject orgJson = new org.json.JSONObject(jsonString);：这行代码创建一个新的 org.json.JSONObject 对象，并使用 jsonString 中的 JSON 字符串进行初始化。结果赋值给名为 orgJson 的 org.json.JSONObject 类型变量。
return orgJson;：这行代码返回转换后的 org.json.JSONObject 类型的对象 orgJson。
}：这是方法结束的括号。

这个方法的目的是在两个不同的 JSON 库之间进行转换：将 com.alibaba.fastjson 类型的 JSON 对象转换为 org.json 类型的 JSON 对象。这在实际项目中可能会用到，特别是当需要在不同的库之间进行互操作时。请注意，这个方法的名字应该改为 fastJsonToOrgJson 以更准确地表示它的功能。

③将 org.json.JSONArray 类型的 JSON 数组转换为 com.alibaba.fastjson.JSONArray 类型的 JSON 数组

public static com.alibaba.fastjson.JSONArray orgJsonArrayToFasterxmlArray(org.json.JSONArray orgJsonArray) {
        String jsonString = orgJsonArray.toString();
        com.alibaba.fastjson.JSONArray fastJsonArray = com.alibaba.fastjson.JSON.parseArray(jsonString);
        return fastJsonArray;
    }

这段代码是一个 Java 方法，用于将 org.json.JSONArray 类型的 JSON 数组转换为 com.alibaba.fastjson.JSONArray 类型的 JSON 数组。以下是对每一行的详细解释：

public static com.alibaba.fastjson.JSONArray orgJsonArrayToFasterxmlArray(org.json.JSONArray orgJsonArray) {：这行代码定义了一个名为 orgJsonArrayToFasterxmlArray 的公共静态方法。该方法接收一个 org.json.JSONArray 类型的参数 orgJsonArray，并返回一个 com.alibaba.fastjson.JSONArray 类型的对象。
String jsonString = orgJsonArray.toString();：这行代码调用 orgJsonArray 对象的 toString 方法，将 orgJsonArray 对象转换为一个 JSON 字符串，并将其赋值给名为 jsonString 的 String 类型变量。
com.alibaba.fastjson.JSONArray fastJsonArray = com.alibaba.fastjson.JSON.parseArray(jsonString);：这行代码调用 com.alibaba.fastjson.JSON 类的 parseArray 方法，将 jsonString 中的 JSON 字符串解析为一个 com.alibaba.fastjson.JSONArray 类型的对象 fastJsonArray。
return fastJsonArray;：这行代码返回转换后的 com.alibaba.fastjson.JSONArray 类型的对象 fastJsonArray。
}：这是 orgJsonArrayToFasterxmlArray 方法的结束括号。

这个方法的目的是在两个不同的 JSON 库之间进行转换：将 org.json 类型的 JSON 数组转换为 com.alibaba.fastjson 类型的 JSON 数组。这在实际项目中可能会用到，特别是当需要在不同的库之间进行互操作时。

④将 com.alibaba.fastjson.JSONArray 类型的 JSON 数组转换为 org.json.JSONArray 类型的 JSON 数组

public static org.json.JSONArray fastjsonArrayToOrgJsonArray(com.alibaba.fastjson.JSONArray fastJsonArray) {
        String jsonString = fastJsonArray.toJSONString();
        org.json.JSONArray orgJsonArray = new org.json.JSONArray(jsonString);
        return orgJsonArray;
    }

这段代码是一个 Java 方法，用于将 com.alibaba.fastjson.JSONArray 类型的 JSON 数组转换为 org.json.JSONArray 类型的 JSON 数组。以下是对每一行的详细解释：

public static org.json.JSONArray fastjsonArrayToOrgJsonArray(com.alibaba.fastjson.JSONArray fastJsonArray) {：这行代码定义了一个名为 fastjsonArrayToOrgJsonArray 的公共静态方法。该方法接收一个 com.alibaba.fastjson.JSONArray 类型的参数 fastJsonArray，并返回一个 org.json.JSONArray 类型的对象。
String jsonString = fastJsonArray.toJSONString();：这行代码调用 fastJsonArray 对象的 toJSONString 方法，将 fastJsonArray 对象转换为一个 JSON 字符串，并将其赋值给名为 jsonString 的 String 类型变量。
org.json.JSONArray orgJsonArray = new org.json.JSONArray(jsonString);：这行代码创建一个新的 org.json.JSONArray 对象，并使用 jsonString 中的 JSON 字符串进行初始化。结果赋值给名为 orgJsonArray 的 org.json.JSONArray 类型变量。
return orgJsonArray;：这行代码返回转换后的 org.json.JSONArray 类型的对象 orgJsonArray。
}：这是方法结束的括号。

这个方法的目的是在两个不同的 JSON 库之间进行转换：将 com.alibaba.fastjson 类型的 JSON 数组转换为 org.json 类型的 JSON 数组。这在实际项目中可能会用到，特别是当需要在不同的库之间进行互操作时。

6.

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSON;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
public class FastJsonExample {
    private static final Map<String, Object> fieldDefaults;
    static {
        fieldDefaults = new HashMap<>();
        fieldDefaults.put("a", 0);
        fieldDefaults.put("b", 2);
        fieldDefaults.put("c", 3);
        fieldDefaults.put("d", 4);
    }
    public static Map<String, Object> filterFieldsToUpdate(JSONObject jsonObject) {
        // 创建结果映射
        Map<String, Object> resultMap = new HashMap<>();
        // 遍历JSONObject的键值对
        for (String key : jsonObject.keySet()) {
            Object value = jsonObject.get(key);
            // 如果fieldDefaults包含该键且值不相等，则添加到结果映射中
            if (fieldDefaults.containsKey(key) && !Objects.equals(value, fieldDefaults.get(key))) {
                resultMap.put(key, value);
            }
        }
        return resultMap;
    }
    public static void main(String[] args) {
        // 示例的JSON字符串
        String jsonString = "{\"a\": 1, \"b\": 2, \"c\": 3}";
        // 将JSON字符串解析为JSONObject
        JSONObject jsonObject = JSON.parseObject(jsonString);
        Map<String, Object> resultMap = filterFieldsToUpdate(jsonObject);
        System.out.println(resultMap);
    }
}

这段代码包含了一个用于过滤更新字段的静态方法 filterFieldsToUpdate，以及一个用于演示该方法的 main 方法。以下是对每一段的详细解释：

private static final Map<String, Object> fieldDefaults;：定义一个私有静态的只读的 Map 对象 fieldDefaults，用于存储字段及其默认值。
static { ... }：这是一个静态代码块，用于初始化 fieldDefaults。在这个示例中，我们将四个键值对添加到 fieldDefaults 中，分别为 “a”: 0, “b”: 2, “c”: 3, “d”: 4。
public static Map<String, Object> filterFieldsToUpdate(JSONObject jsonObject) { ... }：定义一个名为 filterFieldsToUpdate 的公共静态方法，用于过滤 JSON 对象中需要更新的字段。此方法接收一个 JSONObject 参数，并返回一个 Map 类型的对象。
Map<String, Object> resultMap = new HashMap<>();：在 filterFieldsToUpdate 方法中，创建一个名为 resultMap 的 HashMap 对象，用于存储需要更新的字段。
for (String key : jsonObject.keySet()) { ... }：使用一个 for-each 循环遍历输入的 JSON 对象的键。
Object value = jsonObject.get(key);：获取 JSON 对象中当前键对应的值。
if (fieldDefaults.containsKey(key) && !Objects.equals(value, fieldDefaults.get(key))) { ... }：使用一个 if 语句检查 fieldDefaults 是否包含当前键，且当前键的值与 fieldDefaults 中对应的值不相等。如果满足条件，将当前键值对添加到 resultMap 中。
return resultMap;：filterFieldsToUpdate 方法结束时，返回 resultMap。
public static void main(String[] args) { ... }：这是一个 main 方法，用于演示 filterFieldsToUpdate 方法的使用。
String jsonString = "{\"a\": 1, \"b\": 2, \"c\": 3}\";：定义一个 JSON 字符串。
JSONObject jsonObject = JSON.parseObject(jsonString);：将 JSON 字符串解析为一个 JSONObject 对象。
Map<String, Object> resultMap = filterFieldsToUpdate(jsonObject);：调用 filterFieldsToUpdate 方法，传入解析后的 JSONObject 对象，返回一个包含需要更新字段的 Map 对象。
System.out.println(resultMap);：输出结果 Map。