定义 Java 类
你需要有一个与 JSON 数组中每个对象结构相匹配的 Java 类（POJO - Plain Old Java Object），这个类的字段名和类型必须与 JSON 的键和值类型对应。
（图片来源网络，侵删）
假设我们有如下的 JSON 数组：
[
{
"id": 1,
"name": "Alice",
"age": 30,
"isStudent": false
},
{
"id": 2,
"name": "Bob",
"age": 25,
"isStudent": true
}
]
对应的 Java 类 User.java 应该是这样：
// User.java
public class User {
private int id;
private String name;
private int age;
private boolean isStudent;
// 必须有无参构造函数，以便反序列化时创建对象
public User() {
}
// 推荐添加 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 int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean isStudent() {
return isStudent;
}
public void setStudent(boolean student) {
isStudent = student;
}
// (可选) 重写 toString() 方便打印和调试
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", isStudent=" + isStudent +
'}';
}
}
使用 Jackson (最流行)
Jackson 是目前 Java 生态中最流行、性能最好的 JSON 处理库，Spring Boot 等主流框架都默认集成了它。
添加依赖
如果你使用 Maven，在 pom.xml 中添加：
（图片来源网络，侵删）
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.15.2</version> <!-- 使用最新的稳定版本 -->
</dependency>
核心代码
Jackson 提供了 ObjectMapper 类，它是所有操作的入口。
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
public class JacksonExample {
public static void main(String[] args) {
// 1. 创建 ObjectMapper 实例
ObjectMapper objectMapper = new ObjectMapper();
// 2. 定义你的 JSON 字符串
String jsonArrayString = "[\n" +
" {\n" +
" \"id\": 1,\n" +
" \"name\": \"Alice\",\n" +
" \"age\": 30,\n" +
" \"isStudent\": false\n" +
" },\n" +
" {\n" +
" \"id\": 2,\n" +
" \"name\": \"Bob\",\n" +
" \"age\": 25,\n" +
" \"isStudent\": true\n" +
" }\n" +
"]";
try {
// 3. 使用 readValue 方法进行转换
// 关键点：使用 TypeReference 来明确指定目标集合的类型是 List<User>
List<User> userList = objectMapper.readValue(jsonArrayString, new TypeReference<List<User>>() {});
// 4. 如果需要的是数组而不是 List，可以调用 toArray 方法
User[] userArray = userList.toArray(new User[0]);
// 5. 打印结果验证
System.out.println("转换成功，List<User> 大小: " + userList.size());
userList.forEach(System.out::println);
System.out.println("\n转换成功，User[] 大小: " + userArray.length);
for (User user : userArray) {
System.out.println(user);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
代码解释：
objectMapper.readValue(...)是核心方法，用于将 JSON 字符串反序列化为 Java 对象。new TypeReference<List<User>>() {}是一个非常关键的技巧，由于 Java 的类型擦除，List<User>在运行时实际上是List。TypeReference帮助 Jackson 在运行时保留完整的泛型信息，从而正确地将 JSON 数组中的每个元素解析为User对象。
使用 Gson (Google)
Gson 是 Google 提供的另一个非常流行的 JSON 库，使用起来也很简单。
添加依赖
Maven (pom.xml):
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.10.1</version> <!-- 使用最新的稳定版本 -->
</dependency>
核心代码
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.List;
public class GsonExample {
public static void main(String[] args) {
// 1. 创建 Gson 实例
Gson gson = new Gson();
// 2. 定义你的 JSON 字符串
String jsonArrayString = "[\n" +
" {\n" +
" \"id\": 1,\n" +
" \"name\": \"Alice\",\n" +
" \"age\": 30,\n" +
" \"isStudent\": false\n" +
" },\n" +
" {\n" +
" \"id\": 2,\n" +
" \"name\": \"Bob\",\n" +
" \"age\": 25,\n" +
" \"isStudent\": true\n" +
" }\n" +
"]";
try {
// 3. 使用 fromJson 方法进行转换
// 关键点：使用 TypeToken 来明确指定目标集合的类型
Type userListType = new TypeToken<List<User>>() {}.getType();
List<User> userList = gson.fromJson(jsonArrayString, userListType);
// 4. 如果需要的是数组而不是 List，可以调用 toArray 方法
User[] userArray = userList.toArray(new User[0]);
// 5. 打印结果验证
System.out.println("转换成功，List<User> 大小: " + userList.size());
userList.forEach(System.out::println);
System.out.println("\n转换成功，User[] 大小: " + userArray.length);
for (User user : userArray) {
System.out.println(user);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
代码解释：
gson.fromJson(...)是 Gson 的核心反序列化方法。new TypeToken<List<User>>() {}.getType()与 Jackson 的TypeReference作用完全相同，都是为了解决 Java 泛型类型擦除的问题，让 Gson 知道要解析成List<User>而不是List。
使用 Spring Boot (推荐)
如果你的项目是基于 Spring Boot 的，事情会变得更简单，Spring Boot 自动配置了 ObjectMapper，你可以直接注入使用。
确保 Spring Boot Web 依赖
你的 pom.xml 中应该包含 spring-boot-starter-web，它会自动引入 Jackson。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
核心代码
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;
@Component // 标记为 Spring 组件，以便注入
public class SpringJsonConverter {
// Spring 会自动配置并注入一个 ObjectMapper 实例
@Autowired
private ObjectMapper objectMapper;
public void convertJsonArray() {
String jsonArrayString = "[\n" +
" {\n" +
" \"id\": 1,\n" +
" \"name\": \"Alice\",\n" +
" \"age\": 30,\n" +
" \"isStudent\": false\n" +
" },\n" +
" {\n" +
" \"id\": 2,\n" +
" \"name\": \"Bob\",\n" +
" \"age\": 25,\n" +
" \"isStudent\": true\n" +
" }\n" +
"]";
try {
// 使用方式与纯 Jackson 完全一样
List<User> userList = objectMapper.readValue(jsonArrayString, new TypeReference<List<User>>() {});
System.out.println("Spring Boot 环境下转换成功，List<User> 大小: " + userList.size());
userList.forEach(System.out::println);
} catch (Exception e) {
e.printStackTrace();
}
}
}
总结与对比
| 特性 | Jackson | Gson | Spring Boot (内置 Jackson) |
|---|---|---|---|
| 易用性 | 非常易用，功能强大 | 非常易用，API 简洁 | 最简单，直接注入 ObjectMapper |
| 性能 | 非常高，业界标杆 | 性能良好，但通常略逊于 Jackson | 性能与 Jackson 一致 |
| 功能 | 功能最全面，支持流式 API、树模型等 | 功能齐全，专注于 JSON | 功能与 Jackson 一致 |
| 集成度 | Spring Boot 默认集成 | 需要手动集成 | 无缝集成，开箱即用 |
| 选择建议 | 新项目首选，尤其是高性能要求的场景 | Google 出品，稳定可靠，老项目或不想用 Jackson 的场景 | Spring 项目首选，无需关心底层实现 |
Java 数组 vs. List
在实际开发中,将 JSON 数组直接转为 List<T> 通常比转为 T[] 数组更常见、更方便，因为 List 是 Java 集合框架的一部分，提供了更丰富、更灵活的操作方法（如 add, remove, size 等），只有在调用某些特定 API 必须需要数组时，才需要使用 toArray() 方法进行转换。
最终结论：
- 如果你在做一个新的 Java 项目，推荐使用 Jackson。
- 如果你的项目是 Spring Boot，直接使用注入的
ObjectMapper即可，代码最简洁。 - 如果你更喜欢 Google 的生态，Gson 是一个非常好的备选。
