目前最主流、最推荐的库是 Jackson 和 Gson，下面我将分别详细介绍如何使用这两个库进行转换，并涵盖复杂场景（如 List<Map> 和 List<自定义对象>）。
（图片来源网络，侵删）
准备工作：添加依赖
你需要在你的项目中添加相应库的依赖。
如果使用 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 转换为 List<Map<String, Object>>
这是最简单的情况，因为 Map 可以非常灵活地表示 JSON 中的键值对结构。
使用 Jackson
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
import java.util.Map;
public class JsonToListMapWithJackson {
public static void main(String[] args) {
String jsonString = "[{\"name\":\"Alice\",\"age\":30},{\"name\":\"Bob\",\"city\":\"New York\"}]";
ObjectMapper objectMapper = new ObjectMapper();
try {
// 使用 TypeReference 来明确指定目标类型是 List<Map<String, Object>>
List<Map<String, Object>> list = objectMapper.readValue(jsonString, new TypeReference<List<Map<String, Object>>>() {});
// 打印结果
for (Map<String, Object> map : list) {
System.out.println(map);
// 可以通过 map.get("key") 来获取值
System.out.println("Name: " + map.get("name"));
System.out.println("Age: " + map.get("age")); // age 可能是 Integer 类型
System.out.println("City: " + map.get("city")); // city 可能是 null
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
关键点：
ObjectMapper是 Jackson 的核心类。readValue方法用于将 JSON 字符串反序列化为 Java 对象。new TypeReference<...>() {}是一个“技巧”，用于在泛型擦除的情况下，让readValue方法能正确识别List的泛型类型是Map<String, Object>。
使用 Gson
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
public class JsonToListMapWithGson {
public static void main(String[] args) {
String jsonString = "[{\"name\":\"Alice\",\"age\":30},{\"name\":\"Bob\",\"city\":\"New York\"}]";
Gson gson = new Gson();
// 使用 TypeToken 来获取正确的类型
Type listType = new TypeToken<List<Map<String, Object>>>() {}.getType();
try {
List<Map<String, Object>> list = gson.fromJson(jsonString, listType);
// 打印结果
for (Map<String, Object> map : list) {
System.out.println(map);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
关键点：
（图片来源网络，侵删）
Gson是 Gson 的核心类。fromJson方法用于反序列化。new TypeToken<...>() {}.getType()是 Gson 中用来获取泛型类型的标准方式，与 Jackson 的TypeReference作用类似。
JSON 转换为 List<自定义对象>
这是在实际开发中更常见的场景，你需要一个 Java 类来与 JSON 的结构一一对应。
步骤：
- 创建一个 Java 类（POJO - Plain Old Java Object），其字段名和类型与 JSON 中的键和值类型匹配。
- 使用 Jackson 或 Gson 的 API 进行转换。
示例 JSON
[
{
"id": 1,
"name": "Product A",
"price": 99.99,
"inStock": true
},
{
"id": 2,
"name": "Product B",
"price": 49.50,
"inStock": false
}
]
创建对应的 Java 类 Product.java
// 使用 Lombok 可以简化代码，但不是必须的
// import lombok.Data;
// @Data
public class Product {
private int id;
private String name;
private double price;
private boolean inStock;
// 必须提供一个无参构造函数，以便 Jackson/Gson 反射创建对象
public Product() {
}
// Getters and Setters (或者使用 Lombok 的 @Data 注解自动生成)
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 double getPrice() { return price; }
public void setPrice(double price) { this.price = price; }
public boolean isInStock() { return inStock; }
public void setInStock(boolean inStock) { this.inStock = inStock; }
@Override
public String toString() {
return "Product{" +
"id=" + id +
", name='" + name + '\'' +
", price=" + price +
", inStock=" + inStock +
'}';
}
}
使用 Jackson 进行转换
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
public class JsonToListObjectWithJackson {
public static void main(String[] args) {
String jsonString = "[{\"id\":1,\"name\":\"Product A\",\"price\":99.99,\"inStock\":true},{\"id\":2,\"name\":\"Product B\",\"price\":49.50,\"inStock\":false}]";
ObjectMapper objectMapper = new ObjectMapper();
try {
// 使用 TypeReference 指定 List<Product> 类型
List<Product> productList = objectMapper.readValue(jsonString, new TypeReference<List<Product>>() {});
// 打印结果
for (Product product : productList) {
System.out.println(product);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
使用 Gson 进行转换
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.List;
public class JsonToListObjectWithGson {
public static void main(String[] args) {
String jsonString = "[{\"id\":1,\"name\":\"Product A\",\"price\":99.99,\"inStock\":true},{\"id\":2,\"name\":\"Product B\",\"price\":49.50,\"inStock\":false}]";
Gson gson = new Gson();
// 使用 TypeToken 指定 List<Product> 类型
Type listType = new TypeToken<List<Product>>() {}.getType();
try {
List<Product> productList = gson.fromJson(jsonString, listType);
// 打印结果
for (Product product : productList) {
System.out.println(product);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
总结与对比
| 特性 | Jackson | Gson |
|---|---|---|
| 性能 | 通常更快，功能强大，是高性能的首选。 | 性能也很好，但通常略逊于 Jackson。 |
| API | ObjectMapper 是核心，API 相对统一。 |
Gson 是核心，API 简单直观。 |
| 灵活性 | 非常灵活，支持复杂的注解（如 @JsonFormat, @JsonProperty）来定制序列化和反序列化行为。 |
灵活性也很好，注解系统同样强大。 |
| 易用性 | 对于简单场景，使用 TypeReference 可能稍显繁琐。 |
对于泛型集合，使用 TypeToken 是标准做法，比较直观。 |
| 生态系统 | Spring Boot 默认使用 Jackson，与 Spring 生态无缝集成，社区支持最广泛。 | 独立库，也非常流行，但不是 Spring 的默认选择。 |
如何选择？
- 新项目，特别是基于 Spring Boot 的项目：强烈推荐 Jackson，它是事实上的标准，性能好，与 Spring 生态集成完美。
- 需要快速实现，或者项目已经在使用 Gson：Gson 是一个非常好的选择，API 简单,易于上手。
- 性能是最高优先级：进行基准测试，但 Jackson 通常在大多数场景下表现更优。
希望这个详细的指南能帮助你理解在 Java 中如何进行 JSON 到 List 的转换！
