FastJSON2 JSON 类中 toJSONString()、parseObject()、parseArray() 三个核心方法的详细使用形式说明与示例

好的，以下是对 FastJSON2 JSON 类中 toJSONString()、parseObject()、parseArray() 三个核心方法的详细使用形式说明与示例。

---

✅ FastJSON2 核心方法详解与实战示例

📌 一、toJSONString() 方法

作用：将 Java 对象序列化为 JSON 字符串。

✅ 1.1 基础形式：toJSONString(Object obj)

import com.alibaba.fastjson2.JSON;

public class ToJsonStringExample {
    public static void main(String[] args) {
        // 定义一个简单的 JavaBean
        class Person {
            private String name;
            private int age;
            private String city;

            public Person(String name, int age, String city) {
                this.name = name;
                this.age = age;
                this.city = city;
            }
            // getter/setter (此处省略，实际项目推荐用 Lombok)
            public String getName() { return name; }
            public void setName(String name) { this.name = name; }
            public int getAge() { return age; }
            public void setAge(int age) { this.age = age; }
            public String getCity() { return city; }
            public void setCity(String city) { this.city = city; }
        }

        // 创建一个 Java 对象实例
        Person person = new Person("张三", 28, "北京");

        // 将 Java 对象转换为 JSON 字符串（最基础用法）
        String jsonStr = JSON.toJSONString(person);
        System.out.println("基础序列化结果: " + jsonStr);
        // 输出: {"age":28,"city":"北京","name":"张三"}
    }
}

✅ 1.2 进阶形式：toJSONString(Object obj, JSONWriter.Feature... features)

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.config.JSONWriter;

public class ToJsonStringWithFeatureExample {
    public static void main(String[] args) {
        class User {
            private String name;
            private Integer age; // 使用包装类型，以便为 null
            private String email; // 该字段为 null

            public User(String name, Integer age) {
                this.name = name;
                this.age = age;
                // this.email = null; // 默认就是 null
            }
            // getter/setter (省略)
            public String getName() { return name; }
            public void setName(String name) { this.name = name; }
            public Integer getAge() { return age; }
            public void setAge(Integer age) { this.age = age; }
            public String getEmail() { return email; }
            public void setEmail(String email) { this.email = email; }
        }

        User user = new User("李四", 30); // email 为 null

        // --- 1.2.1 默认行为：不输出 null 字段 ---
        String defaultJson = JSON.toJSONString(user);
        System.out.println("默认（不输出 null）: " + defaultJson);
        // 输出: {"age":30,"name":"李四"}

        // --- 1.2.2 使用 Feature：输出 null 字段 ---
        String withNullJson = JSON.toJSONString(user, JSONWriter.Feature.WriteMapNullValue);
        System.out.println("输出 null 字段: " + withNullJson);
        // 输出: {"age":30,"email":null,"name":"李四"}

        // --- 1.2.3 使用 Feature：格式化输出（美化） ---
        String prettyJson = JSON.toJSONString(user, JSONWriter.Feature.PrettyFormat);
        System.out.println("格式化输出:\n" + prettyJson);
        /*
        输出:
        {
            "age": 30,
            "name": "李四"
        }
        */

        // --- 1.2.4 组合多个 Feature ---
        String combinedJson = JSON.toJSONString(user,
                JSONWriter.Feature.WriteMapNullValue, // 输出 null
                JSONWriter.Feature.PrettyFormat      // 格式化
        );
        System.out.println("组合 Feature 输出:\n" + combinedJson);
        /*
        输出:
        {
            "age": 30,
            "email": null,
            "name": "李四"
        }
        */
    }
}

---

📌 二、parseObject() 方法

作用：将 JSON 字符串反序列化为 Java 对象。

✅ 2.1 基础形式：parseObject(String text, Class<T> clazz)

import com.alibaba.fastjson2.JSON;

public class ParseObjectBasicExample {
    public static void main(String[] args) {
        // 定义目标 JavaBean
        class Person {
            private String name;
            private int age;
            private String city;

            public Person() {} // 必须有无参构造器

            // getter/setter (省略)
            public String getName() { return name; }
            public void setName(String name) { this.name = name; }
            public int getAge() { return age; }
            public void setAge(int age) { this.age = age; }
            public String getCity() { return city; }
            public void setCity(String city) { this.city = city; }
            @Override public String toString() { return "Person{" + "name='" + name + "', age=" + age + ", city='" + city + "'}"; }
        }

        // JSON 字符串
        String jsonStr = "{\"name\":\"王五\",\"age\":35,\"city\":\"上海\"}";

        // 将 JSON 字符串解析为指定的 Java 对象
        Person person = JSON.parseObject(jsonStr, Person.class);
        System.out.println("反序列化结果: " + person);
        // 输出: 反序列化结果: Person{name='王五', age=35, city='上海'}
    }
}

✅ 2.2 进阶形式：parseObject(String text, Class<T> clazz, JSONReader.Feature... features)

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.config.JSONReader;

public class ParseObjectWithFeatureExample {
    public static void main(String[] args) {
        class Person {
            private String name;
            private int age;
            // getter/setter (省略)
            public String getName() { return name; }
            public void setName(String name) { this.name = name; }
            public int getAge() { return age; }
            public void setAge(int age) { this.age = age; }
            @Override public String toString() { return "Person{" + "name='" + name + "', age=" + age + '}'; }
        }

        // JSON 字符串，字段名与 JavaBean 不完全匹配（大小写不一致）
        String jsonWithWrongCase = "{\"Name\":\"赵六\",\"AGE\":29}";

        // --- 2.2.1 默认行为：严格匹配，可能失败或字段为 null ---
        Person personDefault = JSON.parseObject(jsonWithWrongCase, Person.class);
        System.out.println("默认解析结果: " + personDefault);
        // 输出: 默认解析结果: Person{name='null', age=0} (字段名不匹配导致映射失败)

        // --- 2.2.2 使用 Feature：忽略字段名大小写 ---
        Person personIgnoreCase = JSON.parseObject(jsonWithWrongCase, Person.class,
                JSONReader.Feature.IgnoreCase);
        System.out.println("忽略大小写解析结果: " + personIgnoreCase);
        // 输出: 忽略大小写解析结果: Person{name='赵六', age=29}
    }
}

✅ 2.3 泛型形式：parseObject(String text, TypeReference<T> type)

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.TypeReference;

import java.util.List;
import java.util.Map;

public class ParseObjectGenericExample {
    public static void main(String[] args) {
        class User {
            private String name;
            private int age;
            // getter/setter (省略)
            public String getName() { return name; }
            public void setName(String name) { this.name = name; }
            public int getAge() { return age; }
            public void setAge(int age) { this.age = age; }
            @Override public String toString() { return "User{" + "name='" + name + "', age=" + age + '}'; }
        }

        // --- 2.3.1 解析泛型 List ---
        String listJson = "[{\"name\":\"用户A\",\"age\":25},{\"name\":\"用户B\",\"age\":30}]";
        // 使用 TypeReference 来捕获泛型信息，避免运行时类型擦除
        List<User> userList = JSON.parseObject(listJson, new TypeReference<List<User>>() {});
        System.out.println("解析 List<User> 结果: " + userList);
        // 输出: 解析 List<User> 结果: [User{name='用户A', age=25}, User{name='用户B', age=30}]

        // --- 2.3.2 解析泛型 Map ---
        String mapJson = "{\"user1\":{\"name\":\"管理员\",\"age\":35},\"user2\":{\"name\":\"访客\",\"age\":20}}";
        Map<String, User> userMap = JSON.parseObject(mapJson, new TypeReference<Map<String, User>>() {});
        System.out.println("解析 Map<String, User> 结果: " + userMap.get("user1"));
        // 输出: 解析 Map<String, User> 结果: User{name='管理员', age=35}
    }
}

---

📌 三、parseArray() 方法

作用：将 JSON 数组字符串反序列化为 JSONArray 对象或 List<T>。

✅ 3.1 基础形式：parseArray(String text)

import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSON;

public class ParseArrayBasicExample {
    public static void main(String[] args) {
        // JSON 数组字符串
        String jsonArrayStr = "[\"apple\", \"banana\", \"orange\"]";

        // 将 JSON 数组字符串解析为 JSONArray 对象（类似 List<Object>）
        JSONArray jsonArray = JSON.parseArray(jsonArrayStr);
        System.out.println("解析为 JSONArray: " + jsonArray);
        System.out.println("数组大小: " + jsonArray.size());
        System.out.println("第一个元素: " + jsonArray.getString(0)); // 自动转换为 String
        // 输出: 解析为 JSONArray: ["apple", "banana", "orange"]
        // 输出: 数组大小: 3
        // 输出: 第一个元素: apple
    }
}

✅ 3.2 泛型形式：parseArray(String text, Class<T> clazz)

import com.alibaba.fastjson2.JSON;

import java.util.List;

public class ParseArrayGenericExample {
    public static void main(String[] args) {
        class Product {
            private String name;
            private double price;
            // getter/setter (省略)
            public String getName() { return name; }
            public void setName(String name) { this.name = name; }
            public double getPrice() { return price; }
            public void setPrice(double price) { this.price = price; }
            @Override public String toString() { return "Product{" + "name='" + name + "', price=" + price + '}'; }
        }

        // JSON 数组字符串，包含对象
        String jsonArrayStr = "[{\"name\":\"iPhone 15\",\"price\":5999.0},{\"name\":\"MacBook Air\",\"price\":8999.0}]";

        // 将 JSON 数组字符串解析为 List<Product>
        List<Product> productList = JSON.parseArray(jsonArrayStr, Product.class);
        System.out.println("解析为 List<Product> 结果: " + productList);
        // 输出: 解析为 List<Product> 结果: [Product{name='iPhone 15', price=5999.0}, Product{name='MacBook Air', price=8999.0}]
    }
}

✅ 3.3 泛型形式（与 parseObject 配合）：parseObject(text, new TypeReference<List<T>>() {})

注意：对于 List<T> 类型，parseArray 和 parseObject with TypeReference 是等效的，但 parseArray 更语义化。
对于 Set<T>、Map<K,V> 等其他集合类型，必须使用 parseObject with TypeReference。

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.TypeReference;

import java.util.Set;

public class ParseArrayWithSetExample {
    public static void main(String[] args) {
        // JSON 数组字符串
        String jsonArrayStr = "[\"item1\", \"item2\", \"item1\"]"; // 包含重复项

        // 无法用 parseArray 直接解析为 Set，因为其返回值是 JSONArray 或 List
        // 必须使用 parseObject 配合 TypeReference
        Set<String> itemSet = JSON.parseObject(jsonArrayStr, new TypeReference<Set<String>>() {});
        System.out.println("解析为 Set<String> 结果: " + itemSet);
        // 输出: 解析为 Set<String> 结果: [item2, item1] (去重)
    }
}

---

✅ 总结与最佳实践

方法	最佳实践	说明
toJSONString(obj)	用于基础序列化	默认不输出 null 字段，性能好
toJSONString(obj, features...)	用于控制输出格式	如需输出 null、格式化输出等
parseObject(text, Class)	用于简单对象反序列化	最安全，避免反序列化漏洞
parseObject(text, TypeReference)	用于泛型集合反序列化	如 List<T>, Map<K,V>
parseObject(text, Class, features...)	用于控制解析行为	如忽略大小写
parseArray(text)	用于解析简单数组	返回 JSONArray 对象
parseArray(text, Class)	用于解析对象数组	返回 List<T>