FastJson中JSON.parseArray、JSON.parseObject 与 TypeReference、JSON.toJSONString用法

1. JSON.parseArray 方法

这个方法用于将JSON数组字符串直接解析为指定类型的Java列表。
举例：
假设我们有一个 JSON 数组字符串，它表示一系列坐标点，每个坐标点都是一个包含经度和纬度的对象。JSON 字符串可能看起来像这样：

[  
  {"latitude": 34.05, "longitude": -118.25},  
  {"latitude": 33.94, "longitude": -118.40}  
]

我们想要将这个 JSON 数组字符串解析为一个 List 类型的列表，其中 CoordinateVO 是一个简单的 Java 类，用于表示坐标点。

首先，定义 CoordinateVO 类：

public class CoordinateVO {  
    private double latitude;  
    private double longitude;  
  
    // 构造函数、getter和setter省略
}

然后，使用 JSON.parseArray 方法解析 JSON 数组字符串：

import com.alibaba.fastjson.JSON;  
import java.util.List;  
  
public class Main {  
    public static void main(String[] args) {  
        String jsonArrayStr = "[{\"latitude\": 34.05, \"longitude\": -118.25}, {\"latitude\": 33.94, \"longitude\": -118.40}]";  
  
        // 使用JSON.parseArray解析JSON数组字符串为List<CoordinateVO>  
        List<CoordinateVO> coordinateVOList = JSON.parseArray(jsonArrayStr, CoordinateVO.class);  
  
        // 遍历列表并打印每个坐标点  
        for (CoordinateVO coordinateVO : coordinateVOList) {  
            System.out.println(coordinateVO);  
        }  
    }  
}

注意：在上面的代码中，我省略了 CoordinateVO 类的构造函数、getter 和 setter 方法的实现，但在实际使用中你应该包含它们。在这个例子中，JSON.parseArray 方法接受两个参数：第一个参数是 JSON 数组字符串，第二个参数是目标 Java 类的 Class 对象，用于指定列表中元素的类型。

2. JSON.parseObject 方法与 TypeReference

JSON.parseObject 方法通常用于将JSON对象字符串解析为Java对象。

1）JSON.parseObject的简单使用

例如：我们使用 JSON.parseObject 方法将一个 JSON 字符串解析为 User 类的实例

import com.alibaba.fastjson.JSON;  
  
public class Main {  
    public static void main(String[] args) {  
        String jsonStr = "{\"id\":1,\"name\":\"John Doe\",\"age\":30}";  
  
        // 使用JSON.parseObject解析JSON字符串为User对象  
        User user = JSON.parseObject(jsonStr, User.class);  
  
        // 打印解析后的User对象  
        System.out.println(user);  
    }  
  
    // 确保User类已经定义好  
}

2）JSON.parseObject 与 TypeReference 的组合用法

JSON.parseObject 与 TypeReference 用于处理更复杂的泛型类型，特别是在JSON字符串代表一个对象（可能是嵌套结构）时，但需要解析为特定类型的集合。它是用来处理那些可能看起来更像对象但实际上内部包含数组或列表的情况，或者当JSON字符串的结构更复杂时。

举例：
假设我们有一个JSON字符串，它表示一个包含多个坐标集的对象，每个坐标集都是一个包含经纬度等信息的对象列表。JSON字符串可能看起来像这样：

{  
  "coordinateSets": [  
    {"id": 1, "latitude": 34.05, "longitude": -118.25},  
    {"id": 2, "latitude": 33.94, "longitude": -118.40}  
  ]  
}

我们想要将这个JSON字符串解析为一个Java对象，该对象包含一个 List 类型的属性。CoordinateSetVO 是一个简单的Java类，用于表示坐标集。

首先，定义 CoordinateSetVO 类：

public class CoordinateSetVO {  
    private int id;  
    private double latitude;  
    private double longitude;  
  
    // 构造函数、getter和setter省略  
}

然后，我们使用 JSON.parseObject 和 TypeReference 来解析JSON字符串：

import com.alibaba.fastjson.JSON;  
import com.alibaba.fastjson.TypeReference;  
  
import java.util.List;  
  
public class Main {  
    public static void main(String[] args) {  
        String jsonStr = "{\"coordinateSets\": [{\"id\": 1, \"latitude\": 34.05, \"longitude\": -118.25}, {\"id\": 2, \"latitude\": 33.94, \"longitude\": -118.40}]}";  
  
        // 定义一个内部类来捕获泛型类型信息  
        class CoordinateSetsWrapper {  
            private List<CoordinateSetVO> coordinateSets;  
  
            // getter和setter省略  
        }  
  
        // 使用TypeReference来解析包含泛型集合的对象  
        CoordinateSetsWrapper wrapper = JSON.parseObject(jsonStr, new TypeReference<CoordinateSetsWrapper>() {});  
        List<CoordinateSetVO> coordinateSetVOList = wrapper.getCoordinateSets();  
  
        // 现在你可以使用coordinateSetVOList了  
        for (CoordinateSetVO set : coordinateSetVOList) {  
            System.out.println("ID: " + set.getId() + ", Latitude: " + set.getLatitude() + ", Longitude: " + set.getLongitude());  
        }  
    }  
  
    // 确保CoordinateSetVO有getId()、getLatitude()和getLongitude()方法  
}

注意，在这个例子中，我们定义了一个内部类 CoordinateSetsWrapper，它包含一个 List 类型的属性。这是因为我们的JSON字符串是一个对象，该对象有一个名为 coordinateSets 的属性，该属性才是我们真正想要解析的列表。通过 TypeReference()，我们告诉fastjson我们想要将JSON字符串解析为 CoordinateSetsWrapper 类型的对象，并且保留 coordinateSets 属性的泛型类型信息。

然后，我们可以从 CoordinateSetsWrapper 对象中获取 coordinateSets 列表，并对其进行进一步处理。

3.JSON.toJSONString 方法

JSON.toJSONString方法非常灵活，它可以处理各种复杂的Java对象，包括集合、数组、嵌套对象等，并将它们转换为相应的JSON字符串表示。
举例：

import com.alibaba.fastjson.JSON;  
  
public class Main {  
    public static void main(String[] args) {  
        // 创建一个Java对象  
        User user = new User();  
        user.setId(1);  
        user.setName("John Doe");  
        user.setAge(30);  
  
        // 使用JSON.toJSONString方法将Java对象转换为JSON字符串  
        String jsonStr = JSON.toJSONString(user);  
  
        // 打印JSON字符串  
        System.out.println(jsonStr);  
    }  
  
    // 假设User类已经定义好，并且包含相应的getter和setter方法  
    static class User {  
        private Integer id;  
        private String name;  
        private int age;  
  
        // 构造函数、getter和setter省略  
    }  
}

import com.alibaba.fastjson.JSON;  
import java.util.ArrayList;  
import java.util.List;  
  
public class ListToJsonExample {  
    public static void main(String[] args) {  
        // 创建一个List并添加一些元素  
        List<User> userList = new ArrayList<>();  
        userList.add(new User(1, "Alice", 25));  
        userList.add(new User(2, "Bob", 30));  
        userList.add(new User(3, "Charlie", 35));  
  
        // 使用JSON.toJSONString方法将List转换为JSON字符串  
        String jsonStr = JSON.toJSONString(userList);  
  
        // 打印JSON字符串  
        System.out.println(jsonStr);  
    }  
  
    // 假设User类已经定义好，并且包含相应的getter和setter方法  
    static class User {  
        private Integer id;  
        private String name;  
        private int age;  
  
        // 构造函数  
        public User(Integer id, String name, int age) {  
            this.id = id;  
            this.name = name;  
            this.age = age;  
        }  
  
        // getter和setter方法省略  
    }  
}

最后，我们打印出了这个JSON字符串，它应该类似于以下格式：

[{"id":1,"name":"Alice","age":25},{"id":2,"name":"Bob","age":30},{"id":3,"name":"Charlie","age":35}]

这个JSON字符串表示了一个JSON数组，其中包含了三个JSON对象，每个对象都对应List中的一个User对象。