- 键值对集合：类似 Java 的
Map<String, Object>，这是最直接对应 JSON 对象（{ "key": "value" }）的形式。 - JSON 字符串：一个符合 JSON 格式的、完整的字符串，
"{ \"name\": \"John\", \"age\": 30 }"，有时我们说的“转化”是指将一个普通的 Java 字符串（如"{name:John, age:30}"，格式不标准）转换成这种规范的 JSON 字符串。
下面我将分情况详细介绍如何实现这些转化,并推荐目前最主流和方便的工具库。
（图片来源网络，侵删）
核心工具库推荐
在 Java 生态中，处理 JSON 最流行的库有三个：
- Jackson：目前最流行、功能最强大的 JSON 库，Spring Framework 的默认选择。
- Gson：Google 出品，API 简洁易用,非常适合快速上手。
- org.json：一个轻量级的库，API 非常直观。
强烈推荐使用 Jackson 或 Gson，因为它们功能更全面、性能更好、社区更活跃。org.json 虽然轻量,但在处理复杂对象时略显笨拙。
将一个 JSON 格式的 String 转化为 Java 对象 (如 Map 或自定义类)
这是最常见的场景：你有一个符合 JSON 格式的字符串，希望把它解析成 Java 中可以操作的数据结构。
方法 1：使用 Jackson (推荐)
在你的项目中添加 Jackson 的依赖（以 Maven 为例）：
（图片来源网络，侵删）
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.15.2</version> <!-- 请使用最新版本 -->
</dependency>
示例代码：
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;
public class JacksonStringToJson {
public static void main(String[] args) {
// 1. 准备一个 JSON 格式的字符串
// 注意：字符串内部的 " 必须被转义为 \"
String jsonString = "{\"name\":\"John Doe\",\"age\":30,\"isStudent\":false,\"courses\":[\"Math\",\"Science\"]}";
// 2. 创建 ObjectMapper 实例
ObjectMapper objectMapper = new ObjectMapper();
try {
// 3. 将 JSON 字符串转化为 Map
// TypeReference 是一个泛型工具，用于告诉 ObjectMapper 要转换成什么具体类型
Map<String, Object> dataMap = objectMapper.readValue(jsonString, new TypeReference<Map<String, Object>>() {});
// 4. 验证结果
System.out.println("成功将 JSON 字符串转化为 Map:");
System.out.println("Name: " + dataMap.get("name")); // 输出: Name: John Doe
System.out.println("Age: " + dataMap.get("age")); // 输出: Age: 30
System.out.println("Courses: " + dataMap.get("courses")); // 输出: Courses: [Math, Science]
} catch (Exception e) {
e.printStackTrace();
}
}
}
要点：
objectMapper.readValue()是核心方法，用于读取（解析）JSON。new TypeReference<Map<String, Object>>()非常重要，它解决了泛型类型擦除的问题，让 Jackson 知道我们要创建的是一个Map。- 转化后的
Map的值类型是Object，因为 JSON 中的值可以是字符串、数字、布尔、数组、对象等。
方法 2：使用 Gson
添加 Gson 依赖（Maven）：
<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.Map;
public class GsonStringToJson {
public static void main(String[] args) {
String jsonString = "{\"name\":\"John Doe\",\"age\":30,\"isStudent\":false,\"courses\":[\"Math\",\"Science\"]}";
// 1. 创建 Gson 实例
Gson gson = new Gson();
try {
// 2. 定义要转换的目标类型
Type mapType = new TypeToken<Map<String, Object>>() {}.getType();
// 3. 将 JSON 字符串转化为 Map
Map<String, Object> dataMap = gson.fromJson(jsonString, mapType);
// 4. 验证结果
System.out.println("成功将 JSON 字符串转化为 Map:");
System.out.println("Name: " + dataMap.get("name"));
System.out.println("Age: " + dataMap.get("age"));
System.out.println("Courses: " + dataMap.get("courses"));
} catch (Exception e) {
e.printStackTrace();
}
}
}
要点：
gson.fromJson()是核心方法。new TypeToken<Map<String, Object>>() {}.getType()的作用与 Jackson 的TypeReference类似,用于获取具体的泛型类型。
将一个普通字符串（非标准JSON）转化为 JSON 字符串
这种情况比较特殊，通常指将一个自定义格式的字符串（如 key1:value1,key2:value2）转换成标准的 JSON 字符串 ({"key1":"value1","key2":"value2"})，这通常需要手动处理，因为库无法“猜测”你的自定义格式。
示例：
假设我们有这样一个字符串：name:John, age:30, city:New York
我们可以手动将其解析并构建成 JSON 字符串。
import java.util.HashMap;
import java.util.Map;
public class StringToJsonBuilder {
public static void main(String[] args) {
String rawString = "name:John, age:30, city:New York";
// 1. 手动解析字符串
Map<String, String> keyValueMap = new HashMap<>();
String[] pairs = rawString.split(",");
for (String pair : pairs) {
String[] keyValue = pair.split(":");
if (keyValue.length == 2) {
String key = keyValue[0].trim();
// 处理值，确保它被双引号包围
String value = "\"" + keyValue[1].trim() + "\"";
keyValueMap.put(key, value);
}
}
// 2. 使用 Jackson 或 Gson 将 Map 转化为 JSON 字符串
ObjectMapper objectMapper = new ObjectMapper();
try {
// 使用 `objectMapper.writeValueAsString()` 将对象/Map转为JSON字符串
String jsonString = objectMapper.writeValueAsString(keyValueMap);
System.out.println("原始字符串: " + rawString);
System.out.println("转化后的 JSON 字符串: " + jsonString);
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出：
原始字符串: name:John, age:30, city:New York
转化后的 JSON 字符串: {"name":"John","age":"30","city":"New York"}注意： 这种方法很脆弱，如果原始字符串的格式稍有变化（比如用 代替 ，或者有空格等），就可能出错，在生产环境中，应尽量让数据源提供标准格式的 JSON。
将 JSON 字符串转化为自定义的 Java 对象 (POJO/DTO)
这是更规范、更面向对象的做法，如果你有一个固定的 JSON 结构，可以创建一个 Java 类（POJO - Plain Old Java Object）来与之对应。
定义 Java 类
// courses.json 的 Java 对象表示
class Course {
private String name;
private int credits;
// Getters, Setters, and Constructors (Lombok can simplify this)
public Course() {}
public Course(String name, int credits) {
this.name = name;
this.credits = credits;
}
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getCredits() { return credits; }
public void setCredits(int credits) { this.credits = credits; }
@Override
public String toString() {
return "Course{name='" + name + "', credits=" + credits + "}";
}
}
// student.json 的 Java 对象表示
class Student {
private String name;
private int age;
private boolean isStudent;
private List<Course> courses;
// Getters, Setters, and Constructors
public Student() {}
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; }
public List<Course> getCourses() { return courses; }
public void setCourses(List<Course> courses) { this.courses = courses; }
@Override
public String toString() {
return "Student{name='" + name + "', age=" + age + ", isStudent=" + isStudent + ", courses=" + courses + "}";
}
}
使用 Jackson 进行转化
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
public class JsonToPojo {
public static void main(String[] args) {
String jsonString = "{\"name\":\"John Doe\",\"age\":30,\"isStudent\":false,\"courses\":[{\"name\":\"Math\",\"credits\":4},{\"name\":\"Science\",\"credits\":3}]}";
ObjectMapper objectMapper = new ObjectMapper();
try {
// 直接将 JSON 字符串转化为 Student 对象
Student student = objectMapper.readValue(jsonString, Student.class);
// 验证结果
System.out.println("成功将 JSON 字符串转化为 Student 对象:");
System.out.println(student);
System.out.println("First course: " + student.getCourses().get(0));
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出：
成功将 JSON 字符串转化为 Student 对象:
Student{name='John Doe', age=30, isStudent=false, courses=[Course{name='Math', credits=4}, Course{name='Science', credits=3}]}
First course: Course{name='Math', credits=4}优点：
- 类型安全：编译时就能检查出很多错误。
- 代码可读性强：使用
student.getName()比map.get("name")更清晰。 - IDE 支持更好**：自动补全、重构等。
总结与最佳实践
| 需求 | 推荐工具 | 核心方法 | 关键点 |
|---|---|---|---|
JSON String -> Map |
Jackson / Gson | readValue(jsonString, Map.class) |
使用 TypeReference 或 TypeToken 处理泛型。 |
| JSON String -> 自定义 POJO | Jackson / Gson | readValue(jsonString, MyClass.class) |
定义与 JSON 结构匹配的 Java 类，并确保有 getter/setter。 |
| 普通 String -> JSON String | 手动 + Jackson/Gson | 手动解析为 Map，然后用 writeValueAsString() |
此方法脆弱，尽量避免，让数据源提供标准 JSON。 |
| 任意 Object -> JSON String | Jackson / Gson | writeValueAsString(myObject) |
这是序列化，与反序列化（读）是相反的操作。 |
最终建议：
- 选择一个库并坚持使用：在同一个项目中，不要混用 Jackson 和 Gson，以避免依赖冲突和不必要的复杂性。Jackson 是目前社区和 Spring 生态的主流选择。
- 优先使用 POJO：JSON 结构是固定的，定义对应的 Java 类是最好的实践，它能让你的代码更健壮、更易于维护。
- 处理异常：
readValue可能会抛出JsonParseException（如果字符串格式错误）或JsonMappingException（JSON 结构与目标类型不匹配），记得用try-catch包裹。 - 考虑使用 Lombok：为你的 POJO 类添加
@Getter,@Setter,@NoArgsConstructor,@AllArgsConstructor等注解,可以大大减少样板代码。
