准备工作：添加依赖

你需要在你的项目中添加相应的库依赖。

使用 Jackson (推荐)

如果你使用 Maven，在 pom.xml 中添加：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version> <!-- 使用最新的稳定版本 -->
</dependency>

如果你使用 Gradle，在 build.gradle 中添加：

implementation 'com.fasterxml.jackson.core:jackson-databind:2.15.2' // 使用最新的稳定版本

使用 Gson

如果你使用 Maven，在 pom.xml 中添加：

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version> <!-- 使用最新的稳定版本 -->
</dependency>

如果你使用 Gradle，在 build.gradle 中添加：

implementation 'com.google.code.gson:gson:2.10.1' // 使用最新的稳定版本

JSON 字符串 → Java 对象数组 (List<T>)

这是最常见的情况，JSON 数组中的每个元素都是一个复杂的对象（而不仅仅是基本类型）。

示例 JSON 字符串

假设我们有以下 JSON 字符串,它表示一个用户列表：

[
  { "id": 1, "name": "Alice", "email": "alice@example.com" },
  { "id": 2, "name": "Bob", "email": "bob@example.com" },
  { "id": 3, "name": "Charlie", "email": "charlie@example.com" }
]

步骤 1：创建对应的 Java 类（POJO）

你需要创建一个与 JSON 对象结构匹配的 Java 类，Jackson 和 Gson 都会利用反射来将 JSON 字段映射到 Java 类的字段。

// User.java
public class User {
    private int id;
    private String name;
    private String email;
    // 必须提供一个无参构造函数，以便库可以实例化对象
    public User() {
    }
    // 为了方便，可以添加一个全参构造函数
    public User(int id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }
    // 添加 Getter 和 Setter 方法
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    // (可选) 重写 toString() 方便打印和调试
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

步骤 2：进行转换

使用 Jackson

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
public class JacksonJsonToList {
    public static void main(String[] args) throws Exception {
        String jsonString = "[\n" +
                "  { \"id\": 1, \"name\": \"Alice\", \"email\": \"alice@example.com\" },\n" +
                "  { \"id\": 2, \"name\": \"Bob\", \"email\": \"bob@example.com\" },\n" +
                "  { \"id\": 3, \"name\": \"Charlie\", \"email\": \"charlie@example.com\" }\n" +
                "]";
        // 1. 创建 ObjectMapper 实例
        ObjectMapper objectMapper = new ObjectMapper();
        // 2. 使用 readValue 方法进行转换
        //    - 第一个参数是 JSON 字符串
        //    - 第二个参数是目标集合的类型
        //    - 使用 TypeReference 来明确指定 List<User> 的泛型类型，这是最安全的方式
        List<User> userList = objectMapper.readValue(jsonString, new TypeReference<List<User>>() {});
        // 3. 打印结果
        System.out.println("转换成功！用户列表:");
        userList.forEach(System.out::println);
    }
}

使用 Gson

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.List;
public class GsonJsonToList {
    public static void main(String[] args) {
        String jsonString = "[\n" +
                "  { \"id\": 1, \"name\": \"Alice\", \"email\": \"alice@example.com\" },\n" +
                "  { \"id\": 2, \"name\": \"Bob\", \"email\": \"bob@example.com\" },\n" +
                "  { \"id\": 3, \"name\": \"Charlie\", \"email\": \"charlie@example.com\" }\n" +
                "]";
        // 1. 创建 Gson 实例
        Gson gson = new Gson();
        // 2. 使用 fromJson 方法进行转换
        //    - 第一个参数是 JSON 字符串
        //    - 第二个参数是目标集合的类型
        //    - 使用 TypeToken 来获取包含泛型信息的 Type 对象
        Type userListType = new TypeToken<List<User>>() {}.getType();
        List<User> userList = gson.fromJson(jsonString, userListType);
        // 3. 打印结果
        System.out.println("转换成功！用户列表:");
        userList.forEach(System.out::println);
    }
}

JSON 字符串 → Java 基本类型数组

JSON 数组中的元素是基本类型（如字符串、数字、布尔值）,转换会更简单。

示例 JSON 字符串

["苹果", "香蕉", "橙子"]

使用 Jackson

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
public class JacksonJsonToPrimitiveList {
    public static void main(String[] args) throws Exception {
        String jsonString = "[\"苹果\", \"香蕉\", \"橙子\"]";
        ObjectMapper objectMapper = new ObjectMapper();
        // 直接使用 List.class 是不够的，因为类型擦除
        // 必须使用 TypeReference 来明确 List<String> 的类型
        List<String> fruitList = objectMapper.readValue(jsonString, new TypeReference<List<String>>() {});
        System.out.println("水果列表: " + fruitList);
    }
}

使用 Gson

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.List;
public class GsonJsonToPrimitiveList {
    public static void main(String[] args) {
        String jsonString = "[\"苹果\", \"香蕉\", \"橙子\"]";
        Gson gson = new Gson();
        // 同样，需要 TypeToken 来获取 List<String> 的类型
        Type fruitListType = new TypeToken<List<String>>() {}.getType();
        List<String> fruitList = gson.fromJson(jsonString, fruitListType);
        System.out.println("水果列表: " + fruitList);
    }
}

总结与最佳实践

最佳实践建议：

1. 选择一个并坚持使用：对于新项目，Jackson 通常是首选，因为它与 Java 生态（尤其是 Spring）集成得非常好。
2. 使用 POJO 类：对于复杂的 JSON，创建对应的 Java 类（POJO）是最佳实践,因为它提供了类型安全和代码可读性。
3. 正确处理泛型：当将 JSON 数组转换为 List<T> 时，必须使用 TypeReference (Jackson) 或 TypeToken (Gson) 来指定泛型类型，否则会得到 List 而不是 List<User>,可能导致类型转换异常。
4. 处理异常：在实际应用中，JSON 字符串可能格式不正确，应该将转换逻辑放在 try-catch 块中，捕获 JsonProcessingException (Jackson) 或 JsonSyntaxException (Gson)。
5. 考虑 JSON 数组 vs. JSON 对象：请确保你的 JSON 字符串确实是一个数组（以 [ 开头，以 ] ，如果它是一个包含数组属性的对象（如 {"users": [...]}），你需要先解析对象，再获取 users 属性。