核心概念
要将 JSON 转换为 List,关键在于两点：
（图片来源网络，侵删）
- JSON 的结构：JSON 数组
[]会被直接映射为 Java 的List或数组。["apple", "banana"]会变成List<String>。 - 泛型类型：
List是一个泛型集合List<T>，你必须明确告诉 Jackson/Gson 这个T是什么类型（String,User,Integer等），JSON 数组中的每个元素都必须是这个T类型或可以被转换成这个T类型。
["apple", "banana"]->List<String>[1, 2, 3]->List<Integer>[{"name": "Alice"}, {"name": "Bob"}]->List<User>(User是一个自定义的 Java 类)
使用 Jackson (推荐)
Jackson 是目前 Java 生态中最流行、性能最好的 JSON 库。
添加依赖
如果你使用 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' // 建议使用最新版本
核心代码
Jackson 的核心类是 ObjectMapper。
（图片来源网络，侵删）
场景 A：JSON 数组转 List<String>
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
public class JacksonListStringExample {
public static void main(String[] args) {
String jsonString = "[\"apple\", \"banana\", \"cherry\"]";
ObjectMapper objectMapper = new ObjectMapper();
try {
// 使用 TypeReference 来明确指定目标类型是 List<String>
// 这是最关键的一步！
List<String> fruitList = objectMapper.readValue(jsonString, new TypeReference<List<String>>() {});
System.out.println("转换成功: " + fruitList);
System.out.println("第一个水果: " + fruitList.get(0)); // 输出: apple
} catch (Exception e) {
e.printStackTrace();
}
}
}
场景 B：JSON 数组转自定义对象 List<User>
这是更常见的场景，定义一个 User 类。
// User.java
public class User {
private String name;
private int age;
// 必须有无参构造函数，Jackson 在反序列化时会用到
public User() {
}
// 推荐：使用 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;
}
// 重写 toString() 方便打印
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
然后进行转换：
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
public class JacksonListObjectExample {
public static void main(String[] args) {
String jsonString = "[{\"name\":\"Alice\",\"age\":30},{\"name\":\"Bob\",\"age\":24}]";
ObjectMapper objectMapper = new ObjectMapper();
try {
// 使用 TypeReference 明确指定目标类型是 List<User>
List<User> userList = objectMapper.readValue(jsonString, new TypeReference<List<User>>() {});
System.out.println("转换成功:");
userList.forEach(System.out::println);
// 访问第一个用户
User firstUser = userList.get(0);
System.out.println("第一个用户的名字: " + firstUser.getName()); // 输出: Alice
} catch (Exception e) {
e.printStackTrace();
}
}
}
使用 Gson
Google 的 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' // 建议使用最新版本
核心代码
Gson 的核心类是 Gson。
场景 A：JSON 数组转 List<String>
import com.google.gson.reflect.TypeToken;
import com.google.gson.Gson;
import java.util.List;
public class GsonListStringExample {
public static void main(String[] args) {
String jsonString = "[\"apple\", \"banana\", \"cherry\"]";
Gson gson = new Gson();
try {
// Gson 使用 TypeToken 来处理泛型，与 Jackson 类似
List<String> fruitList = gson.fromJson(jsonString, new TypeToken<List<String>>() {}.getType());
System.out.println("转换成功: " + fruitList);
System.out.println("第一个水果: " + fruitList.get(0)); // 输出: apple
} catch (Exception e) {
e.printStackTrace();
}
}
}
场景 B：JSON 数组转自定义对象 List<User>
同样，我们使用上面定义的 User 类。
import com.google.gson.reflect.TypeToken;
import com.google.gson.Gson;
import java.util.List;
public class GsonListObjectExample {
public static void main(String[] args) {
String jsonString = "[{\"name\":\"Alice\",\"age\":30},{\"name\":\"Bob\",\"age\":24}]";
Gson gson = new Gson();
try {
// 使用 TypeToken 明确指定目标类型是 List<User>
List<User> userList = gson.fromJson(jsonString, new TypeToken<List<User>>() {}.getType());
System.out.println("转换成功:");
userList.forEach(System.out::println);
// 访问第一个用户
User firstUser = userList.get(0);
System.out.println("第一个用户的名字: " + firstUser.getName()); // 输出: Alice
} catch (Exception e) {
e.printStackTrace();
}
}
}
使用 Java 内置库 org.json (不推荐用于复杂项目)
如果你的项目不能引入第三方库，可以使用 JDK 自带的 org.json 库，但请注意，它的性能和灵活性不如 Jackson/Gson,并且需要手动处理类型转换。
添加依赖 (通常需要单独添加)
Maven (pom.xml):
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20251013</version> <!-- 建议使用最新版本 -->
</dependency>
核心代码
import org.json.JSONArray;
import org.json.JSONObject;
import java.util.ArrayList;
import java.util.List;
public class OrgJsonExample {
public static void main(String[] args) {
String jsonString = "[{\"name\":\"Alice\",\"age\":30},{\"name\":\"Bob\",\"age\":24}]";
try {
// 1. 将整个字符串解析为 JSONArray
JSONArray jsonArray = new JSONArray(jsonString);
// 2. 创建一个空的 ArrayList 来存放 User 对象
List<User> userList = new ArrayList<>();
// 3. 遍历 JSONArray
for (int i = 0; i < jsonArray.length(); i++) {
// 4. 获取每个元素，它是一个 JSONObject
JSONObject jsonObject = jsonArray.getJSONObject(i);
// 5. 从 JSONObject 中取出数据，手动创建 User 对象
User user = new User();
user.setName(jsonObject.getString("name"));
user.setAge(jsonObject.getInt("age"));
// 6. 将 User 对象添加到 List 中
userList.add(user);
}
System.out.println("转换成功:");
userList.forEach(System.out::println);
// 访问第一个用户
User firstUser = userList.get(0);
System.out.println("第一个用户的名字: " + firstUser.getName()); // 输出: Alice
} catch (Exception e) {
e.printStackTrace();
}
}
}
缺点：这种方法代码冗长，需要手动进行类型转换和对象创建，容易出错,且性能较低。
总结与对比
| 特性 | Jackson | Gson | org.json (内置) |
|---|---|---|---|
| 易用性 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐ |
| 性能 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐ |
| 功能丰富度 | ⭐⭐⭐⭐⭐ (支持流式 API, 树模型等) | ⭐⭐⭐⭐ | ⭐⭐ |
| 依赖管理 | 需要添加 jackson-databind |
需要添加 gson |
通常需要单独添加 org.json |
| 推荐场景 | 所有生产环境项目的首选 | 生产环境项目的优质选择 | 简单脚本、小型项目或不能引入第三方库的极端情况 |
最终建议：
对于任何正式的项目，强烈推荐使用 Jackson 或 Gson，它们是行业标准，提供了最好的性能、最简洁的代码和最强大的功能，选择哪一个通常取决于项目已有的技术栈或个人偏好,两者都非常出色。
