核心思路
无论使用哪个库,核心思路都是相同的：
（图片来源网络，侵删）
- 引入依赖：在你的项目中添加 JSON 处理库的 Maven 或 Gradle 依赖。
- 创建 JSON 字符串：准备好一个表示 JSON 数组的字符串。
- 调用解析方法：使用库提供的方法，将 JSON 字符串解析成 Java 对象。
- 如果目标类型是
List,通常直接解析即可。 - 如果目标类型是数组（如
String[],User[]），则需要使用TypeReference或类似机制来指定目标类型的完整信息，因为 Java 的数组类型在泛型擦除时会丢失其元素类型信息。
- 如果目标类型是
使用 Jackson (推荐)
Jackson 是目前 Java 社区最流行、性能最好的 JSON 库之一。
1 添加 Maven 依赖
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.15.2</version> <!-- 使用最新版本 -->
</dependency>
2 示例代码
Jackson 的 ObjectMapper 是核心类。
JSON 数组转 Java 数组 (String[])
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.util.Arrays;
public class JacksonArrayExample {
public static void main(String[] args) {
// 1. 准备 JSON 数组字符串
String jsonArrayString = "[\"apple\", \"banana\", \"orange\"]";
// 2. 创建 ObjectMapper 实例
ObjectMapper objectMapper = new ObjectMapper();
try {
// 3. 使用 TypeReference 指定目标类型为 String[]
// 这是关键步骤，因为 Java 泛型无法直接表示 String[]
String[] fruitArray = objectMapper.readValue(jsonArrayString, new TypeReference<String[]>() {});
// 4. 验证结果
System.out.println("转换成功! Java 数组内容: " + Arrays.toString(fruitArray));
// 输出: 转换成功! Java 数组内容: [apple, banana, orange]
} catch (IOException e) {
e.printStackTrace();
}
}
}
JSON 数组转 Java 对象数组 (User[])
假设我们有 User 类。
// User.java
public class User {
private String name;
private int age;
// 构造方法、getters 和 setters 是必须的 (或者使用 Lombok)
public User() {}
public User(String name, int age) {
this.name = name;
this.age = age;
}
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 + "}";
}
}
转换代码：
（图片来源网络，侵删）
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.util.Arrays;
public class JacksonObjectArrayExample {
public static void main(String[] args) {
String userJsonArrayString = "[{\"name\":\"Alice\",\"age\":30},{\"name\":\"Bob\",\"age\":25}]";
ObjectMapper objectMapper = new ObjectMapper();
try {
// 同样需要使用 TypeReference 来指定 User[]
User[] userArray = objectMapper.readValue(userJsonArrayString, new TypeReference<User[]>() {});
System.out.println("转换成功! Java 对象数组内容: " + Arrays.toString(userArray));
// 输出: 转换成功! Java 对象数组内容: [User{name='Alice', age=30}, User{name='Bob', age=25}]
} catch (IOException e) {
e.printStackTrace();
}
}
}
JSON 数组转 Java List
List 的转换比数组更直接，因为 Jackson 可以自动推断泛型类型。
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.util.List;
public class JacksonListExample {
public static void main(String[] args) {
String jsonArrayString = "[\"apple\", \"banana\", \"orange\"]";
ObjectMapper objectMapper = new ObjectMapper();
try {
// 直接指定为 List<String>
List<String> fruitList = objectMapper.readValue(jsonArrayString, new TypeReference<List<String>>() {});
System.out.println("转换成功! Java List 内容: " + fruitList);
// 输出: 转换成功! Java List 内容: [apple, banana, orange]
} catch (IOException e) {
e.printStackTrace();
}
}
}
使用 Gson
Google 的 Gson 库也非常流行,使用起来相对简单。
1 添加 Maven 依赖
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.10.1</version> <!-- 使用最新版本 -->
</dependency>
2 示例代码
Gson 的核心是 Gson 类。
JSON 数组转 Java 数组
Gson 对数组的支持非常直接，不需要 TypeReference。
（图片来源网络，侵删）
import com.google.gson.Gson;
import java.util.Arrays;
public class GsonArrayExample {
public static void main(String[] args) {
String jsonArrayString = "[\"apple\", \"banana\", \"orange\"]";
Gson gson = new Gson();
// 直接使用 gson.fromJson()，Gson 能自动推断
String[] fruitArray = gson.fromJson(jsonArrayString, String[].class);
System.out.println("转换成功! Java 数组内容: " + Arrays.toString(fruitArray));
// 输出: 转换成功! Java 数组内容: [apple, banana, orange]
}
}
JSON 数组转 Java 对象数组
同样非常直接。
import com.google.gson.Gson;
import java.util.Arrays;
// 假设 User 类同上
public class GsonObjectArrayExample {
public static void main(String[] args) {
String userJsonArrayString = "[{\"name\":\"Alice\",\"age\":30},{\"name\":\"Bob\",\"age\":25}]";
Gson gson = new Gson();
// 直接指定 User[].class
User[] userArray = gson.fromJson(userJsonArrayString, User[].class);
System.out.println("转换成功! Java 对象数组内容: " + Arrays.toString(userArray));
// 输出: 转换成功! Java 对象数组内容: [User{name='Alice', age=30}, User{name='Bob', age=25}]
}
}
JSON 数组转 Java List
对于 List，Gson 需要使用 TypeToken 来保留泛型信息。
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.List;
public class GsonListExample {
public static void main(String[] args) {
String jsonArrayString = "[\"apple\", \"banana\", \"orange\"]";
Gson gson = new Gson();
// 1. 创建 TypeToken 来捕获 List<String> 的完整类型信息
Type listType = new TypeToken<List<String>>() {}.getType();
// 2. 使用这个 Type 进行解析
List<String> fruitList = gson.fromJson(jsonArrayString, listType);
System.out.println("转换成功! Java List 内容: " + fruitList);
// 输出: 转换成功! Java List 内容: [apple, banana, orange]
}
}
使用 Fastjson (阿里巴巴)
Fastjson 是由阿里巴巴开发的，以其高性能和易用性著称，但需要注意其版本 1.x 和 2.x 有较大差异，这里以 Fastjson2 为例。
1 添加 Maven 依赖
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
<version>2.0.40</version> <!-- 使用最新版本 -->
</dependency>
2 示例代码
Fastjson2 的核心是 JSON 类。
JSON 数组转 Java 数组
Fastjson2 的转换也极为简洁。
import com.alibaba.fastjson2.JSON;
import java.util.Arrays;
public class Fastjson2ArrayExample {
public static void main(String[] args) {
String jsonArrayString = "[\"apple\", \"banana\", \"orange\"]";
// 直接使用 JSON.parseObject() 并指定目标类型
String[] fruitArray = JSON.parseObject(jsonArrayString, String[].class);
System.out.println("转换成功! Java 数组内容: " + Arrays.toString(fruitArray));
// 输出: 转换成功! Java 数组内容: [apple, banana, orange]
}
}
JSON 数组转 Java 对象数组
同样直接。
import com.alibaba.fastjson2.JSON;
import java.util.Arrays;
// 假设 User 类同上
public class Fastjson2ObjectArrayExample {
public static void main(String[] args) {
String userJsonArrayString = "[{\"name\":\"Alice\",\"age\":30},{\"name\":\"Bob\",\"age\":25}]";
User[] userArray = JSON.parseObject(userJsonArrayString, User[].class);
System.out.println("转换成功! Java 对象数组内容: " + Arrays.toString(userArray));
// 输出: 转换成功! Java 对象数组内容: [User{name='Alice', age=30}, User{name='Bob', age=25}]
}
}
JSON 数组转 Java List
Fastjson2 同样需要使用 TypeReference 来处理 List 的泛型。
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.TypeReference;
import java.util.List;
public class Fastjson2ListExample {
public static void main(String[] args) {
String jsonArrayString = "[\"apple\", \"banana\", \"orange\"]";
// 使用 TypeReference
List<String> fruitList = JSON.parseObject(jsonArrayString, new TypeReference<List<String>>() {});
System.out.println("转换成功! Java List 内容: " + fruitList);
// 输出: 转换成功! Java List 内容: [apple, banana, orange]
}
}
总结与对比
| 特性 | Jackson | Gson | Fastjson2 |
|---|---|---|---|
| 依赖引入 | jackson-databind |
gson |
fastjson2 |
| 核心类 | ObjectMapper |
Gson |
JSON |
| 转数组 | 需要使用 TypeReference |
直接，如 String[].class |
直接，如 String[].class |
| 转List | 需要使用 TypeReference |
需要使用 TypeToken |
需要使用 TypeReference |
| 性能 | 非常好 | 良好 | 非常好 |
| 生态 | 最流行，社区活跃 | Google出品，稳定可靠 | 阿里巴巴出品，国内流行 |
| 建议 | 首选，功能强大，生态完善 | 简单易用，适合小型项目 | 性能极高，适合对性能有极致要求的场景 |
如何选择？
- 新项目，无特殊要求：Jackson 是最稳妥、最通用的选择。
- 追求极致的简洁性：如果你主要处理的是数组和简单对象，Gson 的代码看起来最干净。
- 追求极致的性能：如果你的应用对 JSON 解析的性能有非常高的要求，Fastjson2 是一个强有力的竞争者。
- 处理复杂泛型：Jackson 和 Fastjson2 的
TypeReference机制非常强大和灵活。
希望这份详细的指南能帮助你轻松地将 JSON 数组转换为 Java 数组或集合！
