关于集合的拷贝

最新推荐文章于 2025-06-18 15:22:58 发布
原创 最新推荐文章于 2025-06-18 15:22:58 发布 · 763 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

      昨天遇到的了一个问题，就是说，我把一些经常使用很少更新的数据放到一个静态变量中，在取值的使用直接赋值，由于赋值后的字段需要进行删除数据，结果发现运行一段时间之后发现，集合为空了，经查询发现原来对象的赋值是引用，如果操作这个引用对象就是对那个静态变量做操作。如何解决这个问题哪？一个方式就是在需要这个静态变量时，采用对象的拷贝，别直接赋值。我的那个静态变量是个list集合，所以我就介绍一些list集合拷贝的方式：

    方法一：拷贝值的时候采用 new ArrayList<>(要拷贝的list集合)

    方法二：用list的clone()方法进行拷贝：静态变量.clone()

    方法三：通过list的add()方法把集合添加进去：要赋值的对象.addAll(静态变量)

    方法四，也就是最笨的就是foreach添加。

List集合的复制方式
Mr.xing的博客
05-10 2273
如果要进行深拷贝（deep copy），即创建一个完全独立的新List，其中的元素是原始对象的副本而不是引用，那么需要自行实现深拷贝的逻辑。因此，在多线程环境下进行List集合复制时，需要确保对原始List集合的访问是线程安全的，例如使用线程安全的集合类或者添加适当的同步机制。以上两种复制方式都是浅拷贝（shallow copy），即如果List集合中存储的是对象引用，那么复制后的新List中的元素仍然是原始对象的引用，而不是对象的副本。因此，如果修改了原始对象，这些修改也会反映到复制后的List中。
集合深度拷贝
wltsysterm的博客
02-28 2527
大家常见的拷贝克隆的方法对于集合来说都是浅层拷贝即只是拷贝一个引用。诸如：Collections.addAll() 、Collections.copy(des,src)、list.clone、new ArrayList(list)等都是浅层拷贝，这种很容易造成数据的不安全。要安全的拷贝，深度的拷贝，要通过流-对象流。笔者自己封装的深度拷贝工具类：package com.wlt.collection...
copy ()方法—复制一个集合
weixin_63986098的博客
05-04 3197
copy ()方法—复制一个集合 文章目录copy ()方法—复制一个集合1.语法要点2.实操练习3. =赋值和copy()方法赋值的区别4.课后总结 1.语法要点 copy ()方法的作用：可以复制一个集合。 copy ()方法的作用：可以复制列表中所有元素。 copy ()方法的作用：可以浅复制一个字典。 2.实操练习 # 用{ }创建一个集合 old_set = {'北京','上海','广州'} # 用copy ()方法复制一个集合 new_set = old_set.copy( ) print(
Java中集合的深拷贝与浅拷贝实现
最新发布
echo_123qq的博客
06-18 769
在Java中，集合的拷贝分为浅拷贝(shallow copy)和深拷贝(deep copy)，理解它们的区别及实现方式非常重要。
集合的clone
Closed
03-07 1986
之前看《高质量Java程序设计》，看到有关集合的深层拷贝（Deep Copy）和浅层拷贝（Shadow Copy）。今天试了一下。由于集合本身就是采用引用的方式保存元素的，所以集合.clone()产生的对象其对元素的保存方式也是引用。比如，ArrayList类对象ar 中有元素student1, student2（的引用），现在copy  = ar.clone().那么copy中所保存的也只是
集合里的深拷贝和浅拷贝
Mr.SSY的博客
04-21 1538
浅拷贝（浅克隆）： 复制出来的对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。 深拷贝（深克隆）： 复制出来的所有变量都含有与原来的对象相同的值，那些引用其他对象的变量将指向复制出来的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。 其实本质上的区别就是一个是指针的...
集合的复制
iteye_18797的博客
07-27 175
[size=large]//示例[/size] [size=large]//学生类[/size] package com.softstome.clone.arrayCopy; import java.io.Serializable; public class Student implements Serializable ,Cloneable{ private s...
copy一个集合的方法（深度拷贝和浅度拷贝）
rensheng_ruxi的博客
04-02 2317
1.复制一个集合的方法分为深度拷贝和浅度拷贝，像平常list集合的addAll()和map的直接赋值，都是浅度拷贝，例如： list1.addAll(list); map1=map; 2.有时，我们需要多次使用原集合的值，为了避免对原集合产生影响，我们需要用到深度拷贝，深度拷贝就是将集合中的数据一一取出，再放到新集合中。这里以map作为例子，listmap是一个list集合，...
Java hutool List集合对象拷贝
zjy660358的专栏
07-26 3039
三个对象，一个对象Point，一个对象CustomData。第三个对象IotDataCache用来屏蔽二者差异。问了AI 很多东西牛头不对马尾的，方法名对不上，参数有问题啊什么的。把Point的pointId 和 CustomData的id 都拷贝到IotDataCache中。有点基础的我相信都能看得懂。iotCode字段不变。
【List】判断集合相等、集合拷贝
weixin_44823875的博客
07-03 1450
浅拷贝只复制某个对象的引用，而不复制对象本身，新旧对象还是共享同一块内存。深拷贝会创造一个一模一样的对象，新对象和原对象不共享内存，修改新对象不会改变原对象。假设 B 复制了 A，当修改 A 时，看 B 是否会发生变化。如果 B 也跟着变了，说明这是浅拷贝，如果 B 没变，那就是深拷贝。
Z-order 和集合拷贝
03-17
1、SendToBack 和 BringToFront 方法是改变 Windows:...2、如何用 Windows 窗体控件集的 CopyTo 方法将控件拷贝到一个数组中？ 关键字：advanced basics,windows,forms controls,Z-order,copying,collections
通过反射拷贝不同泛型的集合
qq_42210804的博客
12-16 444
集合拷贝--通过反射实现
python的深拷贝与浅拷贝
12-21
在Python中，某些数据结构默认进行深拷贝，如不可变类型（如整数、浮点数和字符串），而可变类型（如列表、元组、字典和集合）默认进行浅拷贝。对于可变类型，我们可以使用`.copy()`方法进行浅拷贝，而对于深拷贝，...
拷贝集合类（Copying Collections）
kingkong1024的专栏
07-30 1145
注：如果没有特别指出，这里的集合均指：collection。 对象的复制有两种：浅拷贝和深拷贝。正常的拷贝是浅拷贝，产生一个新的集合，共享原对象的所有权。深拷贝是从原对象创建新的对象，并把这些新对象添加到新的集合。这种差异如图1所示。   图 1. 浅拷贝和深拷贝   浅拷贝 有多种方法来创建一个集合（a collection）的浅拷贝。当你创建一个浅拷贝，便给原来集合的对象发送一
集合的深浅拷贝
qq_52128071的博客
10-29 365
在Java中，如果你希望将一个集合 `url` 复制给另一个集合 `urlList`，并且保证 `url` 中的值更改后 `urlList` 中的值仍然是未更改前的 `url` 值，你需要进行深拷贝（deep copy）。对于简单的 `String` 对象，直接使用浅拷贝方法即可，因为 `String` 是不可变的。对于简单的不可变对象（如 `String`），你可以直接使用浅拷贝方法（如构造函数或 `addAll` 方法），因为这些对象本身是不可变的。通过序列化和反序列化可以实现深拷贝：```java。
集合数据类型，拷贝，深拷贝，浅拷贝
aiyulove201314的博客
05-09 207
5.9自我总结 1.集合数据类型 1.定义 用{}中间值用，隔开，且集合中元素排列是无序的，而且如果有相同元素会只保留一个 2.算法 1.必须掌握 1.长度len set_1 = {1,2,3,4,5} print(len(set_1)) #5 2.成员运算in和not in #表示判断集合里面是否有某个值 set_1 = {1,2,3,4,5} print(1 in set_1) #T...
两个集合间的复制
weixin_40583191的博客
10-25 810
例如：集合A，集合B List A = new ArrayList(); A.add(“哈哈”); A.add(“嗯嗯”); List B = new ArrayList(B); 这样A中的数据B中同样。B还可以使用add进行加数据。
java 集合不同对象拷贝_Java对象和集合拷贝
weixin_33473110的博客
03-02 1231
Java对象和集合的拷贝问题1.今天学习了Java拷贝的问题，其实以前在学习c++的时候也知道对象的深拷贝和浅拷贝的区别，算是有一定的基础，只是在Java中没有深入，前几天在工作中遇到这个问题，当时为了简单，绕过了这个问题，现在用例子说明这个问题。基础类Animal：class Animal {private String name;private String color;public Anim...
集合拷贝几种常用方法
Less Is More
08-13 8718
一种简单的方式是通过构造方 List<Plant> copy = new ArrayList<>(list); 注意：这里拷贝的是引用而不是元素，也就是说某个集合对元素进行修改，则两个集合都会影响 List<Integer> copy = new ArrayList<>(list); 所以对于通过构造方法的方法最好是拷贝不可变的类，例如Integer就是不可以修改的 通过addAll() 和通过构造方法一样是拷贝的引用而不是元素 ..
java 集合拷贝
05-16
### Java集合的深拷贝与浅拷贝 在Java中，集合的拷贝操作通常涉及浅拷贝和深拷贝的概念。以下是关于这两种拷贝方式的具体说明以及其实现方法。 #### 浅拷贝 浅拷贝指的是创建一个新的集合对象，但其内部存储的元素仍然是原有集合中元素的引用。因此，当修改其中一个集合中的可变对象时，另一个集合也会受到影响[^3]。 ##### 实现浅拷贝的方法 1. **使用`clone()`方法** 如果目标集合类实现了`Cloneable`接口，则可以直接调用`clone()`方法完成浅拷贝。 ```java import java.util.ArrayList; import java.util.List; public class ShallowCopyExample { public static void main(String[] args) { List<String> originalList = new ArrayList<>(); originalList.add("A"); originalList.add("B"); // 使用 clone() 进行浅拷贝 List<String> shallowCopiedList = (ArrayList<String>) originalList.clone(); System.out.println("Original List: " + originalList); System.out.println("Shallow Copied List: " + shallowCopiedList); // 修改原始列表不会影响浅拷贝列表（针对不可变对象） originalList.set(0, "X"); System.out.println("After modifying Original List:"); System.out.println("Modified Original List: " + originalList); System.out.println("Unchanged Shallow Copied List: " + shallowCopiedList); } } ``` 2. **使用构造函数** 许多集合类提供了接受现有集合作为参数的构造函数，用于初始化新的集合实例。 ```java import java.util.ArrayList; import java.util.List; public class ConstructorCopyExample { public static void main(String[] args) { List<String> originalList = new ArrayList<>(); originalList.add("C"); originalList.add("D"); // 使用构造函数进行浅拷贝 List<String> copiedList = new ArrayList<>(originalList); System.out.println("Original List: " + originalList); System.out.println("Copied List via constructor: " + copiedList); } } ``` #### 深拷贝 深拷贝不仅复制集合本身，还递归地复制集合内的每一个对象，使得源集合与其副本之间没有任何依赖关系[^3]。这样做的好处是可以确保两个集合互不影响。 ##### 实现深拷贝的方法 1. **手动实现深拷贝逻辑** 对于嵌套的对象结构，需要逐层遍历并克隆每个子对象。 ```java import java.util.ArrayList; import java.util.List; public class DeepCopyManualExample { public static void main(String[] args) throws CloneNotSupportedException { Person person1 = new Person(); Address address1 = new Address("Beijing"); person1.setName("John"); person1.setAddress(address1); // 手动实现深拷贝 Person deepCopiedPerson = new Person(person1.getName(), (Address) person1.getAddress().clone()); System.out.println("Original Person's Address: " + person1.getAddress()); System.out.println("Deep-Copied Person's Address: " + deepCopiedPerson.getAddress()); // 修改深拷贝后的地址 deepCopiedPerson.getAddress().setCity("Shanghai"); System.out.println("After modification:"); System.out.println("Original Person's Address remains unchanged: " + person1.getAddress()); System.out.println("Deep-Copied Person's Address is updated: " + deepCopiedPerson.getAddress()); } static class Person implements Cloneable { private String name; private Address address; public Person() {} public Person(String name, Address address) { this.name = name; this.address = address; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public Address getAddress() { return address; } public void setAddress(Address address) { this.address = address; } } static class Address implements Cloneable { private String city; public Address(String city) { this.city = city; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } public String getCity() { return city; } public void setCity(String city) { this.city = city; } } } ``` 2. **利用序列化机制** 序列化是一种通用的技术手段，适用于大多数情况下的深拷贝需求。 ```java import java.io.*; import java.util.ArrayList; import java.util.List; public class DeepCopySerializationExample { public static void main(String[] args) { try { List<SerializableObject> originalList = new ArrayList<>(); SerializableObject obj1 = new SerializableObject("Item 1", new NestedObject("Nested Item")); SerializableObject obj2 = new SerializableObject("Item 2", new NestedObject("Another Nested Item")); originalList.add(obj1); originalList.add(obj2); // 利用序列化实现深拷贝 ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream); objectOutputStream.writeObject(originalList); ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray()); ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream); List<SerializableObject> deepCopiedList = (List<SerializableObject>) objectInputStream.readObject(); System.out.println("Original List: " + originalList.get(0).getNestedObject().getName()); ((SerializableObject) deepCopiedList.get(0)).getNestedObject().setName("Changed Name"); System.out.println("Deep-Copied List after change: " + deepCopiedList.get(0).getNestedObject().getName()); System.out.println("Original List remains unaffected: " + originalList.get(0).getNestedObject().getName()); } catch (Exception e) { e.printStackTrace(); } } static class SerializableObject implements Serializable { private String name; private NestedObject nestedObject; public SerializableObject(String name, NestedObject nestedObject) { this.name = name; this.nestedObject = nestedObject; } public NestedObject getNestedObject() { return nestedObject; } } static class NestedObject implements Serializable { private String name; public NestedObject(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } } } ``` ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值