准备工作：添加依赖

你需要将相应的库添加到你的项目中。

如果使用 Maven (pom.xml)

对于 Jackson:

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

对于 Gson:

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

如果使用 Gradle (build.gradle)

对于 Jackson:

implementation 'com.fasterxml.jackson.core:jackson-databind:2.15.2'

对于 Gson:

implementation 'com.google.code.gson:gson:2.10.1'

JSON 字符串 -> Java 数组/List

这是最常见的情况，JSON 数据是一个字符串，"[1, 2, 3]" 或 "[{\"name\":\"张三\"}, {\"name\":\"李四\"}]"。

使用 Jackson

Jackson 的核心类是 ObjectMapper。

示例 1：JSON 字符串转 Java 基本类型数组

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Arrays;
public class JacksonJsonToArray {
    public static void main(String[] args) {
        String jsonString = "[1, 2, 3, 4, 5]";
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            // 1. 直接转换为 int[] 数组
            int[] intArray = objectMapper.readValue(jsonString, int[].class);
            System.out.println("转换为 int[] 数组: " + Arrays.toString(intArray));
            // 2. 转换为 Integer[] 数组
            Integer[] integerArray = objectMapper.readValue(jsonString, Integer[].class);
            System.out.println("转换为 Integer[] 数组: " + Arrays.toString(integerArray));
            // 3. 转换为 List<Integer> (更推荐)
            // 使用 TypeReference 来明确指定泛型类型，避免类型擦除问题
            java.util.List<Integer> integerList = objectMapper.readValue(jsonString, new TypeReference<java.util.List<Integer>>() {});
            System.out.println("转换为 List<Integer>: " + integerList);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

示例 2：JSON 字符串转 Java 对象数组/List 假设我们有一个 User 类：

// User.java
public class User {
    private String name;
    private int age;
    // 必须有无参构造函数
    public User() {}
    // Getters and Setters
    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 + "}";
    }
}

我们将包含 User 对象的 JSON 数组字符串进行转换：

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
public class JacksonJsonToObjectArray {
    public static void main(String[] args) {
        String jsonString = "[{\"name\":\"张三\",\"age\":30}, {\"name\":\"李四\",\"age\":25}]";
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            // 1. 转换为 User[] 数组
            User[] userArray = objectMapper.readValue(jsonString, User[].class);
            System.out.println("转换为 User[] 数组:");
            for (User user : userArray) {
                System.out.println(user);
            }
            // 2. 转换为 List<User> (更推荐)
            List<User> userList = objectMapper.readValue(jsonString, new TypeReference<List<User>>() {});
            System.out.println("\n转换为 List<User>:");
            userList.forEach(System.out::println);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

使用 Gson

Gson 的核心类是 Gson。

示例 1：JSON 字符串转 Java 基本类型数组

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.util.Arrays;
import java.util.List;
public class GsonJsonToArray {
    public static void main(String[] args) {
        String jsonString = "[1, 2, 3, 4, 5]";
        Gson gson = new Gson();
        // 1. 转换为 int[] 数组
        int[] intArray = gson.fromJson(jsonString, int[].class);
        System.out.println("转换为 int[] 数组: " + Arrays.toString(intArray));
        // 2. 转换为 Integer[] 数组
        Integer[] integerArray = gson.fromJson(jsonString, Integer[].class);
        System.out.println("转换为 Integer[] 数组: " + Arrays.toString(integerArray));
        // 3. 转换为 List<Integer> (更推荐)
        // 使用 TypeToken 来明确指定泛型类型
        List<Integer> integerList = gson.fromJson(jsonString, new TypeToken<List<Integer>>() {}.getType());
        System.out.println("转换为 List<Integer>: " + integerList);
    }
}

示例 2：JSON 字符串转 Java 对象数组/List 同样使用上面的 User 类。

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.util.List;
public class GsonJsonToObjectArray {
    public static void main(String[] args) {
        String jsonString = "[{\"name\":\"张三\",\"age\":30}, {\"name\":\"李四\",\"age\":25}]";
        Gson gson = new Gson();
        // 1. 转换为 User[] 数组
        User[] userArray = gson.fromJson(jsonString, User[].class);
        System.out.println("转换为 User[] 数组:");
        for (User user : userArray) {
            System.out.println(user);
        }
        // 2. 转换为 List<User> (更推荐)
        List<User> userList = gson.fromJson(jsonString, new TypeToken<List<User>>() {}.getType());
        System.out.println("\n转换为 List<User>:");
        userList.forEach(System.out::println);
    }
}

JSON 对象 -> 数组/List

你的 JSON 数据可能是一个对象,其中一个属性是一个数组。

{
  "status": "success",
  "data": [
    {"name": "王五", "age": 40},
    {"name": "赵六", "age": 22}
  ]
}

这时，你需要先解析整个 JSON 对象,然后再从中提取数组部分。

使用 Jackson

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
// 假设有一个 ResponseWrapper 类来映射外层 JSON
class ResponseWrapper {
    private String status;
    private List<User> data;
    // Getters and Setters
    public String getStatus() { return status; }
    public void setStatus(String status) { this.status = status; }
    public List<User> getData() { return data; }
    public void setData(List<User> data) { this.data = data; }
}
public class JacksonJsonFromArrayInObject {
    public static void main(String[] args) {
        String jsonString = "{\"status\":\"success\",\"data\":[{\"name\":\"王五\",\"age\":40},{\"name\":\"赵六\",\"age\":22}]}";
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            // 1. 先解析成包含数组的对象
            ResponseWrapper wrapper = objectMapper.readValue(jsonString, ResponseWrapper.class);
            System.out.println("外层对象状态: " + wrapper.getStatus());
            // 2. 直接从对象中获取 List
            List<User> userList = wrapper.getData();
            System.out.println("从对象中提取的 List<User>:");
            userList.forEach(System.out::println);
            // 3. 或者使用 JsonNode 来提取 (更灵活)
            // com.fasterxml.jackson.databind.JsonNode rootNode = objectMapper.readTree(jsonString);
            // JsonNode dataArray = rootNode.path("data");
            // List<User> userListFromNode = objectMapper.convertValue(dataArray, new TypeReference<List<User>>() {});
            // System.out.println("从 JsonNode 提取的 List<User>:");
            // userListFromNode.forEach(System.out::println);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

使用 Gson

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.util.List;
// 同样需要一个 ResponseWrapper 类
class ResponseWrapper {
    private String status;
    private List<User> data;
    // Getters and Setters
    public String getStatus() { return status; }
    public void setStatus(String status) { this.status = status; }
    public List<User> getData() { return data; }
    public void setData(List<User> data) { this.data = data; }
}
public class GsonJsonFromArrayInObject {
    public static void main(String[] args) {
        String jsonString = "{\"status\":\"success\",\"data\":[{\"name\":\"王五\",\"age\":40},{\"name\":\"赵六\",\"age\":22}]}";
        Gson gson = new Gson();
        // 1. 先解析成包含数组的对象
        ResponseWrapper wrapper = gson.fromJson(jsonString, ResponseWrapper.class);
        System.out.println("外层对象状态: " + wrapper.getStatus());
        // 2. 直接从对象中获取 List
        List<User> userList = wrapper.getData();
        System.out.println("从对象中提取的 List<User>:");
        userList.forEach(System.out::println);
    }
}

总结与最佳实践

1. 选择库：Jackson 和 Gson 都是业界标准，性能优秀，Jackson 在 Spring Boot 等框架中是默认集成的，如果你在使用这些框架，优先选择 Jackson，Gson 则以其简洁易用著称。
2. 数组 vs. List：在 Java 中，强烈推荐将 JSON 数组转换为 List 集合，而不是原生数组。
   • 灵活性：List（如 ArrayList）的大小是动态的，更符合 JSON 数组的特性。
   • 功能丰富：List 提供了更多有用的方法（如 add, remove, size 等）。
   • 性能：对于绝大多数应用场景，ArrayList 的性能已经足够好。
3. 处理泛型：当将 JSON 数组转换为 List<T> 时，必须使用 TypeReference (Jackson) 或 TypeToken (Gson) 来明确指定泛型类型 T，这是因为在 Java 的类型擦除机制下，List.class 和 List<User>.class 是等价的,编译器无法区分。
4. POJO 类：确保你的 Java 类（如 User）有无参构造函数，并且有对应的 getter 和 setter 方法，这是 JSON 库进行反序列化的基本要求，使用 @JsonProperty 注解可以处理 JSON 键名与 Java 属性名不一致的情况。

希望这份详细的指南能帮助你顺利完成 Java 中 JSON 到数组的转换！