json怎么存list集合

JSON中如何高效存储List集合：实用指南与最佳实践

在Java、Python等编程语言中，List集合是最常用的数据结构之一，用于存储有序、可重复的元素，而JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式，因其简洁性和通用性，成为前后端数据交互、配置文件存储、缓存序列化的首选，如何将List集合转换为JSON格式并高效存储？本文将从基础方法到进阶技巧，结合代码示例，详细解析JSON存储List集合的完整流程。

JSON存储List集合的基础方法：数组与对象列表

JSON本身支持两种核心数据结构来表示List集合：数组（Array）和对象列表（Object Array），选择哪种方式取决于List中存储的数据类型（基本类型/复杂对象）。

存储基本类型List：直接使用数组

当List中的元素是基本类型（如String、Integer、Boolean等）时，JSON可以直接用数组表示，数组的每个元素对应List中的一个值。

示例：Java中使用Gson存储String类型的List

import com.google.gson.Gson;
public class BasicListToJson {
    public static void main(String[] args) {
        // 1. 创建List（存储基本类型）
        List<String> fruitList = Arrays.asList("apple", "banana", "orange");
        // 2. 使用Gson将List转换为JSON数组
        Gson gson = new Gson();
        String jsonStr = gson.toJson(fruitList);
        // 3. 输出JSON结果
        System.out.println(jsonStr); // 输出: ["apple","banana","orange"]
    }
}

示例：Python中使用json模块存储Integer类型的List

import json
# 1. 创建List（存储基本类型）
number_list = [1, 2, 3, 4, 5]
# 2. 使用json.dumps将List转换为JSON数组
json_str = json.dumps(number_list)
# 3. 输出JSON结果
print(json_str)  # 输出: [1, 2, 3, 4, 5]

关键点：

• 基本类型List直接转为JSON数组,无需额外处理，数组的[]对应List的[ ]结构。
• 反序列化时,JSON数组可直接还原为List（如Java中gson.fromJson(jsonStr, new TypeToken<List<String>>(){}.getType())）。

存储复杂对象List：转为对象列表

当List中的元素是自定义对象（如User、Product等实体类）时，JSON需要将每个对象转为一个JSON对象（），整个List转为对象数组（[{...}, {...}, ...]）。

示例：Java中存储自定义对象List（以User为例）

import com.google.gson.Gson;
import java.util.Arrays;
import java.util.List;
// 自定义User类
class User {
    private String name;
    private int age;
    private String email;
    // 构造方法、getter/setter（省略）
    public User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getEmail() { return email; }
}
public class ObjectListToJson {
    public static void main(String[] args) {
        // 1. 创建User对象List
        List<User> userList = Arrays.asList(
            new User("Alice", 25, "alice@example.com"),
            new User("Bob", 30, "bob@example.com")
        );
        // 2. 使用Gson转为JSON对象列表
        Gson gson = new Gson();
        String jsonStr = gson.toJson(userList);
        // 3. 输出JSON结果
        System.out.println(jsonStr);
        // 输出: 
        // [{"name":"Alice","age":25,"email":"alice@example.com"},
        //  {"name":"Bob","age":30,"email":"bob@example.com"}]
    }
}

示例：Python中存储自定义对象List（以Product为例）

import json
from dataclasses import dataclass
# 使用dataclass定义Product类（Python 3.7+）
@dataclass
class Product:
    id: int
    name: str
    price: float
# 1. 创建Product对象List
product_list = [
    Product(1, "Laptop", 999.99),
    Product(2, "Mouse", 29.99)
]
# 2. 将对象转为字典列表，再转为JSON
# 方法1：手动转换（适用于简单对象）
dict_list = [{"id": p.id, "name": p.name, "price": p.price} for p in product_list]
json_str = json.dumps(dict_list)
# 方法2：使用第三方库（如orjson，更高效）
# import orjson
# json_str = orjson.dumps([p.__dict__ for p in product_list]).decode()
print(json_str)
# 输出: 
// [{"id": 1, "name": "Laptop", "price": 999.99},
//  {"id": 2, "name": "Mouse", "price": 29.99}]

关键点：

• 复杂对象需转为JSON对象（），对象属性为键（key），属性值为值（value）。
• 反序列化时,需通过TypeToken（Java）或object_hook（Python）将JSON对象还原为自定义对象。

进阶技巧：处理嵌套List与自定义序列化

实际开发中,List集合可能更复杂（如嵌套List、包含不可序列化对象），此时需结合进阶技巧处理。

嵌套List：多维数组与对象嵌套

当List中包含其他List时（如List<List<String>>），JSON会转为多维数组（[[...], [...]]）。

示例：Java中存储嵌套List

List<List<String>> matrix = Arrays.asList(
    Arrays.asList("A", "B"),
    Arrays.asList("C", "D")
);
Gson gson = new Gson();
String jsonStr = gson.toJson(matrix);
System.out.println(jsonStr); // 输出: [["A","B"],["C","D"]]

示例：Python中存储嵌套对象List（如List[List[User]]）

# 假设已有User类（同Java示例）
user1 = User("Alice", 25, "alice@example.com")
user2 = User("Bob", 30, "bob@example.com")
nested_list = [[user1], [user1, user2]]
# 转换为字典列表的嵌套
json_str = json.dumps([[u.__dict__ for u in inner] for inner in nested_list])
print(json_str)
# 输出: [[{"name": "Alice", "age": 25, "email": "alice@example.com"}],
//       [{"name": "Alice", "age": 25, "email": "alice@example.com"},
//        {"name": "Bob", "age": 30, "email": "bob@example.com"}]]

自定义序列化/反序列化：处理不可序列化对象

若List中包含不可直接序列化的对象（如Date、LocalDateTime），或需调整JSON格式（如日期格式化、字段重命名），需实现自定义序列化逻辑。

示例：Java中处理LocalDateTime（使用Gson注册类型适配器）

import com.google.gson.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class CustomSerialization {
    public static void main(String[] args) {
        List<LocalDateTime> dateTimeList = Arrays.asList(
            LocalDateTime.of(2023, 1, 1, 12, 0),
            LocalDateTime.of(2023, 12, 31, 23, 59)
        );
        // 创建Gson并注册类型适配器
        Gson gson = new GsonBuilder()
                .registerTypeAdapter(LocalDateTime.class, new JsonSerializer<LocalDateTime>() {
                    @Override
                    public JsonElement serialize(LocalDateTime src, java.lang.reflect.Type typeOfSrc, JsonSerializationContext context) {
                        return new JsonPrimitive(src.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
                    }
                })
                .create();
        String jsonStr = gson.toJson(dateTimeList);
        System.out.println(jsonStr); 
        // 输出: ["2023-01-01T12:00:00","2023-12-31T23:59:00"]
    }
}

示例：Python中处理datetime对象（使用default参数）

from datetime import datetime
import json
# 创建包含datetime的List
datetime_list = [datetime(2023, 1, 1, 12, 0), datetime(2023, 12, 31, 23, 59)]
# 自