Python 和 Java 中的浅拷贝与深拷贝详解 | 极客日志

编程语言java算法

Python 和 Java 中的浅拷贝与深拷贝详解

对比分析了 Python 和 Java 语言中的浅拷贝与深拷贝机制。通过实际代码示例揭示了赋值、浅拷贝在处理嵌套可变对象时的潜在风险，即原数据被意外修改。文章详细阐述了 Python 的 copy.deepcopy() 方法与 Java 的手动实现、序列化及第三方库方案。最后总结了在不同场景下如何平衡性能与安全，提供了防御性编程建议和面试避坑指南，帮助开发者避免常见的内存引用陷阱。

山野诗人发布于 2026/3/28更新于 2026/4/164 浏览

引言：拷贝陷阱示例

在实际开发中，常遇到如下配置修改导致的意外问题。

Python 示例

configs = [{"name": "web", "port": }]
backup_configs = configs.copy()

backup_configs[][] = 
(, configs[][])

List<Map<String, Object>> configs = new ArrayList<>();
Map<String, Object> config = new HashMap<>();
config.put("name", "web");
config.put("port", 8080);
configs.add(config);
List<Map<String, Object>> backupConfigs = new ArrayList<>(configs); // 拷贝
backupConfigs.get(0).put("port", 9090);
System.out.println("原配置端口: " + configs.get(0).get("port")); // 也是 9090！

a = [1, 2, 3]
b = a # 这只是贴了个新标签而已
print(a is b) # True，同一个对象
print(id(a), id(b)) # 相同的内存地址
a[0] = 99
print(b) # [99, 2, 3]，b 跟着变了

import copy
a = [1, 2, [3, 4]]
b = a[:] # 切片方式浅拷贝
c = a.copy() # 方法方式浅拷贝
d = list(a) # 构造函数方式浅拷贝
print(a is b) # False，确实创建了新列表
print(a[2] is b[2]) # True！嵌套列表还是同一个

# 修改外层没问题
b.append(5)
print(a) # [1, 2, [3, 4]]，a 没变

# 但修改内层列表...
b[2][0] = 999
print(a) # [1, 2, [999, 4]]！a 的内层也被改了

import copy
a = [1, 2, [3, 4]]
b = copy.deepcopy(a) # 深度拷贝
print(a[2] is b[2]) # False！完全独立的嵌套列表
b[2][0] = 999
print(a) # [1, 2, [3, 4]]，完全不受影响
print(b) # [1, 2, [999, 4]]

// Java 的直接赋值
List<Integer> listA = new ArrayList<>(Arrays.asList(1, 2, 3));
List<Integer> listB = listA; // 不是拷贝，是引用赋值
System.out.println(listA == listB); // true，同一个对象
listA.set(0, 99);
System.out.println(listB.get(0)); // 99，跟着变了

// Java 的浅拷贝
List<Map<String, Integer>> listA = new ArrayList<>();
Map<String, Integer> map = new HashMap<>();
map.put("score", 100);
listA.add(map);
List<Map<String, Integer>> listB = new ArrayList<>(listA); // 浅拷贝
System.out.println(listA.get(0) == listB.get(0)); // true！同一个 Map 对象
listB.get(0).put("score", 0);
System.out.println(listA.get(0).get("score")); // 0！原数据被改了

// 手动深拷贝
List<Map<String, Integer>> deepCopy = new ArrayList<>();
for (Map<String, Integer> map : listA) {
    Map<String, Integer> newMap = new HashMap<>(map); // HashMap 的构造器是浅拷贝
    deepCopy.add(newMap);
}
// 注意：如果 Map 的值也是对象，这仍然是浅拷贝！

// 通过序列化实现深拷贝
import java.io.*;
public static <T extends Serializable> T deepCopy(T obj) {
    try {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(obj);
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (T) ois.readObject();
    } catch (Exception e) {
        throw new RuntimeException("深拷贝失败", e);
    }
}

// 使用 Apache Commons Lang
import org.apache.commons.lang3.SerializationUtils;
List<Map<String, Integer>> deepCopy = SerializationUtils.clone(listA);

// 或者使用 JSON 序列化（Gson/Jackson）
import com.fasterxml.jackson.databind.ObjectMapper;
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(listA);
List<Map<String, Integer>> deepCopy = mapper.readValue(json, new TypeReference<List<Map<String, Integer>>>(){});

特性	Python	Java
直接赋值	同一对象，`a is b`为True	同一引用，`a == b`为True
浅拷贝方法	`list.copy()`, `list[:]`, `copy.copy()`	`new ArrayList<>(oldList)`, `list.clone()`
深拷贝方法	`copy.deepcopy()`	无内置，需手动实现
不可变对象	自动复用，如小整数、字符串	自动装箱的值也是不可变的
可视化程度	`id()`函数直接看地址	无法直接查看对象地址
性能开销	深拷贝代价较高	序列化方式代价很高

// Java 示例
List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 3));
List<Integer> b = new ArrayList<>(a); // Java 的"浅拷贝"
// 在 Java 中，b 是一个新 List 对象
// 但 b 中的 Integer 元素与 a 中的是同一个对象（引用相同）

# Python 示例
a = [1, 2, 3]
b = a[:] # Python 的浅拷贝
# 在 Python 中：
# 1. b 是一个新 list 对象（新地址）
# 2. b 中的元素与 a 中的是同一个对象（对于不可变类型如 int）

// Java 中，变量是'引用盒子'
Integer x = 10; // x 是一个引用，指向 Integer 对象 10
Integer y = x; // y 是另一个引用，指向同一个 Integer 对象
// 拷贝时，创建新盒子，但装的是同样的'地址纸条'
List<Integer> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>(list1); // list2 是新盒子，但里面的纸条（引用）指向同样的对象

# Python 中，变量是'标签'
x = 10 # 标签 x 贴在对象 10 上
y = x # 标签 y 也贴在同一个对象 10 上
# 浅拷贝时，创建新容器，但容器内贴的是同样的标签
a = [1, 2, 3]
b = a[:] # 新容器 b，但 b[0] 和 a[0] 都贴在同一个对象 1 上

a = [1, 2, 3] # 列表可变，但 1,2,3 是整数（不可变）
b = a[:] # 由于整数不可变，共享引用不是问题
a[0] = 99 # 这是把 a[0] 的标签从 1 换到 99
# b[0] 仍然是标签 1，所以不受影响

// 假设元素是自定义的可变对象
class Person { String name; Person(String name) { this.name = name; } }
List<Person> people = new ArrayList<>();
people.add(new Person("Alice"));
List<Person> peopleCopy = new ArrayList<>(people); // peopleCopy[0] 和 people[0] 指向同一个 Person 对象
peopleCopy.get(0).name = "Bob"; // 原列表中的 Alice 也变成了 Bob！

层面	Java 的浅拷贝	Python 的浅拷贝
容器本身	新对象（新地址）	新对象（新地址）
容器内元素	相同的引用	相同的引用
给人的感觉	'感觉像深拷贝'	'明显是浅拷贝'

# 错误示例：配置污染
DEFAULT_CONFIG = {
    "database": {"host": "localhost", "port": 3306},
    "cache": {"enabled": True}
}
def create_user_config(user_id):
    config = DEFAULT_CONFIG # 错误！应该深拷贝
    config["database"]["db_name"] = f"user_{user_id}"
    return config # 第一个用户调用后，DEFAULT_CONFIG 就被污染了！

import copy
def create_user_config(user_id):
    config = copy.deepcopy(DEFAULT_CONFIG) # 深拷贝
    config["database"]["db_name"] = f"user_{user_id}"
    return config

// Java 中的线程安全问题
public class DataProcessor {
    private List<Data> dataList;
    public void process() {
        List<Data> copy = new ArrayList<>(dataList); // 浅拷贝，危险！
        // 如果另一个线程修改了 dataList 中的 Data 对象
        // 这里处理 copy 时可能遇到意外修改
    }
}

// 防御性拷贝
public void process() {
    List<Data> copy = new ArrayList<>();
    for (Data data : dataList) {
        copy.add(data.clone()); // 假设 Data 实现了 clone 方法
    }
    // 现在可以安全处理 copy 了
}

# 如果元素都是不可变类型，浅拷贝完全够用
numbers = (1, 2, 3) # 元组本身就是不可变的
strings = ["a", "b", "c"] # 字符串不可变
# 对这些做浅拷贝很安全

# 延迟深拷贝直到真正需要时
class ConfigManager:
    def __init__(self, config):
        self._original = config
        self._cache = None
    @property
    def config(self):
        if self._cache is None:
            import copy
            self._cache = copy.deepcopy(self._original)
        return self._cache

# 只对可能被修改的部分做深拷贝
def safe_update(config):
    # 外层列表浅拷贝
    new_config = config.copy()
    # 只对需要修改的嵌套结构深拷贝
    if "database" in new_config:
        import copy
        new_config["database"] = copy.deepcopy(new_config["database"])
    return new_config

Python 和 Java 中的浅拷贝与深拷贝详解

引言：拷贝陷阱示例

Python 示例

Java 示例

Python 拷贝的三重境界

境界一：赋值——贴标签游戏

境界二：浅拷贝——新人住旧房

境界三：深拷贝——完全克隆新世界

Java 拷贝的江湖套路

套路一：等号赋值——双胞胎的心灵感应

套路二：构造函数'浅'拷贝——新瓶装旧酒

套路三：实现深拷贝——各显神通

方法 1：手动遍历拷贝（土但有效）

方法 2：序列化大法（通用但较重）

方法 3：第三方库（推荐）

Python vs Java：拷贝大对决

核心区别：什么被拷贝？

Java 的浅拷贝

Python 的浅拷贝

深入理解差异

1. 变量模型的根本不同

Java 是'盒子模型'

Python 是'标签模型'

2. 不可变对象的关键作用

在 Python 中

在 Java 中

3. '新容器'与'新内容'的混淆点

Java 和 Python 拷贝对比总结

实战中的血泪教训

案例 1：配置管理的灾难

案例 2：多线程数据竞争

性能与安全的平衡之道

1. 不可变对象用浅拷贝

2. 写时拷贝（Copy-on-Write）优化

3. 选择性的深拷贝

面试常考题与避坑指南

Q1：Python 中 a = b 和 a = b[:] 有什么区别？

Q2：如何判断一个对象是否需要深拷贝？

Q3：Java 中如何优雅地实现深拷贝？

总结：拷贝的艺术

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具

Q1：Python 中 `a = b` 和 `a = b[:]` 有什么区别？