Java JSON与集合转换

在现代Java应用开发中，JSON(JavaScript Object Notation)作为一种轻量级的数据交换格式，已成为前后端数据传输的标准格式。而Java集合框架是Java程序处理数据的核心容器。因此，掌握JSON与Java集合之间的转换技术是每位Java开发者必备的基础技能。

JSON与集合的关系

在理解转换之前，我们先来看看JSON与Java集合的结构对应关系：

备注

JSON对象（用{}表示）通常对应Java中的Map或实体类(POJO) JSON数组（用[]表示）通常对应Java中的List或数组

常用的JSON处理库

在Java中，常用的JSON库有：

1. Jackson - Spring Boot默认的JSON库
2. Gson - 由Google开发的JSON库
3. fastjson - 阿里巴巴开发的高性能JSON库
4. org.json - 简单易用的JSON库

本文我们主要介绍Jackson和Gson的使用方法，这也是目前使用最广泛的两个库。

Jackson库实现JSON与集合转换

添加依赖

xml

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>

List集合与JSON转换

List转JSON

java

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.ArrayList;
import java.util.List;

public class ListToJsonExample {
    public static void main(String[] args) throws Exception {
        // 创建ObjectMapper对象
        ObjectMapper mapper = new ObjectMapper();
        
        // 创建List集合
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        
        // 将List转换为JSON字符串
        String jsonString = mapper.writeValueAsString(fruits);
        
        System.out.println("List转换为JSON: " + jsonString);
    }
}

输出结果：

List转换为JSON: ["Apple","Banana","Orange"]

JSON转List

java

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;

public class JsonToListExample {
    public static void main(String[] args) throws Exception {
        // 创建ObjectMapper对象
        ObjectMapper mapper = new ObjectMapper();
        
        // JSON字符串
        String jsonString = "[\"Apple\",\"Banana\",\"Orange\"]";
        
        // 将JSON字符串转换为List
        List<String> fruits = mapper.readValue(jsonString, new TypeReference<List<String>>(){});
        
        System.out.println("JSON转换为List: " + fruits);
    }
}

输出结果：

JSON转换为List: [Apple, Banana, Orange]

Map集合与JSON转换

Map转JSON

java

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;

public class MapToJsonExample {
    public static void main(String[] args) throws Exception {
        // 创建ObjectMapper对象
        ObjectMapper mapper = new ObjectMapper();
        
        // 创建Map集合
        Map<String, Object> person = new HashMap<>();
        person.put("name", "张三");
        person.put("age", 25);
        person.put("isStudent", false);
        
        // 将Map转换为JSON字符串
        String jsonString = mapper.writeValueAsString(person);
        
        System.out.println("Map转换为JSON: " + jsonString);
    }
}

输出结果：

Map转换为JSON: {"name":"张三","age":25,"isStudent":false}

JSON转Map

java

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;

public class JsonToMapExample {
    public static void main(String[] args) throws Exception {
        // 创建ObjectMapper对象
        ObjectMapper mapper = new ObjectMapper();
        
        // JSON字符串
        String jsonString = "{\"name\":\"张三\",\"age\":25,\"isStudent\":false}";
        
        // 将JSON字符串转换为Map
        Map<String, Object> person = mapper.readValue(jsonString, new TypeReference<Map<String, Object>>(){});
        
        System.out.println("JSON转换为Map: " + person);
        System.out.println("姓名: " + person.get("name"));
        System.out.println("年龄: " + person.get("age"));
    }
}

输出结果：

JSON转换为Map: {name=张三, age=25, isStudent=false}
姓名: 张三
年龄: 25

复杂嵌套集合与JSON转换

现实应用中，我们经常需要处理嵌套的集合结构，如下所示：

java

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.*;

public class NestedCollectionExample {
    public static void main(String[] args) throws Exception {
        // 创建ObjectMapper对象
        ObjectMapper mapper = new ObjectMapper();
        
        // 创建复杂嵌套集合
        Map<String, Object> course = new HashMap<>();
        course.put("name", "Java编程");
        course.put("teacher", "李教授");
        
        List<Map<String, Object>> students = new ArrayList<>();
        
        Map<String, Object> student1 = new HashMap<>();
        student1.put("name", "张三");
        student1.put("score", 85);
        
        Map<String, Object> student2 = new HashMap<>();
        student2.put("name", "李四");
        student2.put("score", 92);
        
        students.add(student1);
        students.add(student2);
        
        course.put("students", students);
        
        // 转换为JSON
        String jsonString = mapper.writeValueAsString(course);
        
        System.out.println("复杂集合转JSON:\n" + jsonString);
        
        // JSON转回复杂集合
        Map<String, Object> parsedCourse = mapper.readValue(jsonString, 
                                          new TypeReference<Map<String, Object>>(){});
        
        // 获取嵌套的学生列表
        List<Map<String, Object>> parsedStudents = 
            mapper.convertValue(parsedCourse.get("students"), 
                               new TypeReference<List<Map<String, Object>>>(){});
        
        System.out.println("\n解析后的学生列表:");
        for (Map<String, Object> student : parsedStudents) {
            System.out.println("  学生: " + student.get("name") + ", 分数: " + student.get("score"));
        }
    }
}

输出结果：

复杂集合转JSON:
{"name":"Java编程","teacher":"李教授","students":[{"name":"张三","score":85},{"name":"李四","score":92}]}

解析后的学生列表:
  学生: 张三, 分数: 85
  学生: 李四, 分数: 92

Gson库实现JSON与集合转换

添加依赖

xml

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

List集合与JSON转换

java

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

public class GsonListExample {
    public static void main(String[] args) {
        Gson gson = new Gson();
        
        // List转JSON
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        
        String jsonString = gson.toJson(fruits);
        System.out.println("List转JSON: " + jsonString);
        
        // JSON转List
        Type fruitListType = new TypeToken<List<String>>(){}.getType();
        List<String> fruitsList = gson.fromJson(jsonString, fruitListType);
        System.out.println("JSON转List: " + fruitsList);
    }
}

输出结果：

List转JSON: ["Apple","Banana","Orange"]
JSON转List: [Apple, Banana, Orange]

Map集合与JSON转换

java

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.Map;

public class GsonMapExample {
    public static void main(String[] args) {
        Gson gson = new Gson();
        
        // Map转JSON
        Map<String, Object> person = new HashMap<>();
        person.put("name", "张三");
        person.put("age", 25);
        person.put("isStudent", false);
        
        String jsonString = gson.toJson(person);
        System.out.println("Map转JSON: " + jsonString);
        
        // JSON转Map
        Type personMapType = new TypeToken<Map<String, Object>>(){}.getType();
        Map<String, Object> personMap = gson.fromJson(jsonString, personMapType);
        System.out.println("JSON转Map: " + personMap);
        System.out.println("姓名: " + personMap.get("name"));
    }
}

输出结果：

Map转JSON: {"name":"张三","age":25,"isStudent":false}
JSON转Map: {name=张三, age=25.0, isStudent=false}
姓名: 张三

警告

注意Gson在处理数值时默认会将整数转换为double类型，这点与Jackson有所不同。

实际应用场景

场景一：处理RESTful API响应

在与REST API交互时，我们经常需要处理JSON格式的响应数据：

java

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.List;
import java.util.Map;

public class ApiResponseExample {
    public static void main(String[] args) throws Exception {
        // 创建HTTP客户端
        HttpClient client = HttpClient.newHttpClient();
        
        // 创建HTTP请求
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://jsonplaceholder.typicode.com/users"))
            .build();
            
        // 发送请求并获取响应
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        
        // 解析JSON响应
        ObjectMapper mapper = new ObjectMapper();
        List<Map<String, Object>> users = mapper.readValue(response.body(), 
                                         new TypeReference<List<Map<String, Object>>>(){});
        
        // 输出用户数据
        System.out.println("获取到 " + users.size() + " 个用户");
        for (Map<String, Object> user : users) {
            System.out.println("用户ID: " + user.get("id") + 
                             ", 姓名: " + user.get("name") + 
                             ", 邮箱: " + user.get("email"));
            
            // 获取嵌套对象
            Map<String, Object> address = mapper.convertValue(user.get("address"), 
                                         new TypeReference<Map<String, Object>>(){});
            System.out.println("  地址: " + address.get("street") + ", " + address.get("city"));
        }
    }
}

场景二：配置管理

应用程序中常常需要读取或保存配置信息，JSON是常用的配置文件格式：

java

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.util.HashMap;
import java.util.Map;

public class ConfigurationExample {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        
        // 创建配置信息
        Map<String, Object> config = new HashMap<>();
        config.put("appName", "MyJavaApp");
        config.put("version", "1.0.0");
        
        Map<String, Object> database = new HashMap<>();
        database.put("url", "jdbc:mysql://localhost:3306/mydb");
        database.put("username", "admin");
        database.put("password", "********");
        
        config.put("database", database);
        
        // 保存配置到文件
        mapper.writerWithDefaultPrettyPrinter()
              .writeValue(new File("config.json"), config);
        
        System.out.println("配置已保存到config.json文件");
        
        // 从文件读取配置
        Map<String, Object> loadedConfig = mapper.readValue(new File("config.json"), 
                                         new TypeReference<Map<String, Object>>(){});
        
        System.out.println("应用名称: " + loadedConfig.get("appName"));
        System.out.println("版本: " + loadedConfig.get("version"));
        
        // 读取嵌套配置
        Map<String, Object> dbConfig = mapper.convertValue(loadedConfig.get("database"), 
                                      new TypeReference<Map<String, Object>>(){});
        System.out.println("数据库URL: " + dbConfig.get("url"));
    }
}

最佳实践与注意事项

1. 选择合适的库: 根据项目需求选择合适的JSON库，Spring Boot项目推荐使用Jackson，Android项目可以考虑使用Gson。

2. 类型安全: 使用泛型和TypeReference确保类型安全，避免运行时类型转换错误。

3. 性能考虑:

   • 对于大型JSON处理，考虑使用流式API
   • 频繁使用的对象，可以重用ObjectMapper实例而不是每次创建新的

4. 日期处理: JSON标准中没有日期类型，需要特别处理Java中的日期类型。

java

// Jackson日期处理示例
ObjectMapper mapper = new ObjectMapper();
mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
// 或者使用Java 8时间模块
mapper.registerModule(new JavaTimeModule());

5. 空值处理: 默认情况下，Jackson会序列化null值，Gson会忽略null值。

java

// Jackson配置忽略null值
ObjectMapper mapper = new ObjectMapper();
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

小结

本文详细介绍了Java中JSON与集合的互相转换方法，重点讲解了以下内容：

1. JSON与Java集合类型的对应关系
2. 使用Jackson实现List、Map与JSON的转换
3. 使用Gson实现集合与JSON的转换
4. 复杂嵌套集合的JSON处理
5. 实际应用场景示例
6. 最佳实践和注意事项

掌握JSON与集合的转换技术，将帮助你更高效地开发Web应用、处理API数据，以及实现数据持久化。

练习

1. 创建一个包含多种嵌套集合的数据结构（如List中包含Map，Map中又包含List等），并将其转换为JSON，然后再转换回Java对象。

2. 使用Jackson或Gson读取一个REST API（如https://jsonplaceholder.typicode.com/posts），将返回的JSON数据解析为Java集合，并提取特定字段进行操作。

3. 创建一个简单的配置管理系统，能够将应用配置保存为JSON文件，并且能够从文件中读取配置信息到Java应用中。

扩展阅读

• Jackson官方文档
• Gson用户指南
• Java集合框架概述
• JSON官方网站

通过这些资源，你可以进一步深入学习JSON处理技术，开发更强大的Java应用。