精华内容
下载资源
问答
  • public static <E> List<E> deepCopy(List<E> src) { try { ByteArrayOutputStream byteOut = new ByteArrayOutputStream(); ObjectOutputStream out = new...
        public static <E> List<E> deepCopy(List<E> src) {
            try {
                ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
                ObjectOutputStream out = new ObjectOutputStream(byteOut);
                out.writeObject(src);
    
                ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
                ObjectInputStream in = new ObjectInputStream(byteIn);
                @SuppressWarnings("unchecked")
                List<E> dest = (List<E>) in.readObject();
                return dest;
            } catch (Exception e) {
                e.printStackTrace();
                return new ArrayList<E>();
            }
        }

     

    展开全文
  • 由于实体没有用到序列化,没法使用网上深度复制的代码。 1.通过json转换达到目的 import com.alibaba.fastjson.JSON; List<Object> list1= new ArrayList<>(); String jsonString = JSON....

    由于实体没有用到序列化,没法使用网上深度复制的代码。

    1.通过json转换达到目的

    import com.alibaba.fastjson.JSON;

    List<Object> list1 = new ArrayList<>();

    String jsonString = JSON.toJSONString(list1);
    List<Object> list2 = new ArrayList<>();
    list2 = JSON.parseArray(jsonString,Object.class);

     

    2.java1.8通过遍历复制对象完成,用到commons-beanutils的依赖

    import org.apache.commons.beanutils.BeanUtils;

    List<Object> list2 = new ArrayList<>();

    list1.stream().forEach(item->{
                Object o = new Object ();
                try {
                    BeanUtils.copyProperties(o,item);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                list2.add(o);
            });

    展开全文
  • List初始化、集合复制

    千次阅读 多人点赞 2021-01-13 15:00:24
    List集合复制 User类 ...1. 通过循环遍历复制List集合 List<User> userList = new ArrayList<>(); User user0 = new User("a0", "b0"); userList.add(user0); userList.add(new User(

    ArrayList 初始化的三种方式

    1. 使用 Arrays.asList() 实现

    ArrayList<Object> obj = new ArrayList<Type>(Arrays.asList(Object o1, Object o2, Object o3, ....so on));
    

    案例:

    List<String> strList = new ArrayList<String>(Arrays.asList("2", "5", "8", "0"));
    

    ArrayList值:[2, 5, 8, 0]

    2. 通过 匿名内部类 调用 add 方法实现

    List<Object> objList = new ArrayList<Object>() {{ add(Object o1); add(Object o2); add(Object o3); ...}};
    

    案例:

           List<String> strList = new ArrayList<String>(){{
               add("str1"); add("str2"); add("str3");
           }};
    

    ArrayList值:[str1, str2, str3]

    3. 使用 Collections.ncopies() 复制实现指定数目相同内容的赋值

    	// 把元素 element 复制指定次数 num 次,赋值给ArrayList
        List<Object> objList = new ArrayList<Object>(Collections.nCopies(Integer num, Object element));
    

    案例:

    	List<String> strList = new ArrayList<>(Collections.nCopies(10, "str"));
    

    ArrayList值:[str, str, str, str, str, str, str, str, str, str]


    List集合复制

    User类

    class User{
        private String a;
        private String b;
    }
    

    1. 通过循环遍历复制List集合

            List<User> userList = new ArrayList<>();
            User user0 = new User("a0", "b0");
            userList.add(user0);
            userList.add(new User("a1", "b1"));
            userList.add(new User("a2", "b2"));
            //创建临时集合,通过循环遍历赋值
            List<User> temp = new ArrayList<>();
            for(User user: userList){
                temp.add(user);
            }
    		//或者通过new 来赋值
    		/*
    		for(User user: userList){
                User u = new User();
                u.setA(user.getA());
                u.setB(user.getB());
                temp.add(user);
            }
            */
            //修改其中任意集合中的对象属性(修改userList或者temp中的对象)
            userList.get(0).setA("修改AAA000");
            userList.get(0).setB("修改BBB000");
            userList.get(1).setA("修改AAA111");
            userList.get(1).setB("修改BBB111");
    
            System.out.println("userList : " + userList);
            System.out.println("temp : " + temp);	
    

    运行结果:

    userList : [User{a=‘修改AAA000’, b=‘修改BBB000’}, User{a=‘修改AAA111’, b=‘修改BBB111’}, User{a=‘a2’, b=‘b2’}]
    temp : [User{a=‘修改AAA000’, b=‘修改BBB000’}, User{a=‘修改AAA111’, b=‘修改BBB111’}, User{a=‘a2’, b=‘b2’}]

    发现:修改列表中的对象的属性值,另一个列表的值也发生了改变。

    原因:对象之间的值是复制的引用地址,对User的属性A,B修改都是修改的同一常量池的值。

    解决办法:通过new对象,开辟新的内存空间,来修改值。

    		List<User> userList = new ArrayList<>();
            User user0 = new User("a0", "b0");
            userList.add(user0);
            userList.add(new User("a1", "b1"));
            userList.add(new User("a2", "b2"));
            //创建临时集合,通过循环遍历赋值
            List<User> temp = new ArrayList<>();
            for(User user: userList){
                temp.add(user);
            }
            //通过new对象,开辟新的内存空间,来修改值
            userList.set(0, new User("AAA000", "BBB000"));
            System.out.println("userList : " + userList);
            System.out.println("temp : " + temp);
    

    运行结果:

    userList : [User{a=‘AAA000’, b=‘BBB000’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}]
    temp : [User{a=‘a0’, b=‘b0’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}]

    发现:对userList列表的修改,对temp的值没有发生变化

    原因:因为new对象,开辟了新的内存空间,所以两个指向的内存是不同的。

    同理:new一个对象,增加到列表中去,对另一个列表也是没有影响的

     		List<User> userList = new ArrayList<>();
            User user0 = new User("a0", "b0");
            userList.add(user0);
            userList.add(new User("a1", "b1"));
            userList.add(new User("a2", "b2"));
            //创建临时集合,通过循环遍历赋值
            List<User> temp = new ArrayList<>();
            for(User user: userList){
                temp.add(user);
            }
            ///通过new对象,然后新增到列表中
            User userAdd = new User("addA", "addB");
            userList.add(userAdd);
            System.out.println("userList : " + userList);
            System.out.println("temp : " + temp);
    

    运行结果:

    userList : [User{a=‘a0’, b=‘b0’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}, User{a=‘addA’, b=‘addB’}]

    temp : [User{a=‘a0’, b=‘b0’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}]

    发现:新增是不会对复制的列表有什么影响的。

    2. 可以采用ArrayList的addAll()方法来进行复制集合

    addAll()方法:传入参数List,将List中所有的元素加入到新的List集合去,前List会增加的元素个数等于传入的List的大小。

    		List<User> userList = new ArrayList<>();
            User user0 = new User("a0", "b0");
            userList.add(user0);
            userList.add(new User("a1", "b1"));
            userList.add(new User("a2", "b2"));
            
            //创建临时集合,通过addAll方法复制userList集合
            List<User> temp = new ArrayList<>();
            temp.addAll(userList);
            
            userList.get(0).setA("修改AAA000");
            userList.get(0).setB("修改BBB000");
            System.out.println("userList : " + userList);
            System.out.println("temp : " + temp);
    

    运行结果:

    userList : [User{a=‘修改AAA000’, b=‘修改BBB000’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}]

    temp : [User{a=‘修改AAA000’, b=‘修改BBB000’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}]

    3. 其他方式

    //创建临时变量(toArray返回Object)
    List<Object> temp =  Arrays.asList(userList.toArray());
    //直接使用 = 
    //	这种方式只是定义一个引用,指向源集合userList的内容,对其修改新增,两个集合内容变化相同
    List<User> temp = userList;	
    //这种方式,修改两个集合变化相同,新增,另一个无变化
    List<User> temp = new ArrayList<>(userList);
    

    上述方式其实都是浅层复制,当修改原list时,新list也会改变(增加不会),不能达到生成一个完全新的互不影响的list的效果。

    4. 通过Stream复制List生成两个互不影响的集合

            List<User> userList = new ArrayList<>();
            User user0 = new User("a0", "b0");
            userList.add(user0);
            userList.add(new User("a1", "b1"));
            userList.add(new User("a2", "b2"));
    
    		//stream流复制(深度复制)
            List<User> temp = userList.stream().map(user -> {
                //new对象,开辟空间
                User u = new User();
                u.setA(user.getA());
                u.setB(user.getB());
                return u;
            }).collect(Collectors.toList());
            //修改
            userList.get(0).setA("修改AAA000");
            userList.get(0).setB("修改BBB000");
            System.out.println("userList : " + userList);
            System.out.println("temp : " + temp);	
    

    运行结果:

    userList : [User{a=‘修改AAA000’, b=‘修改BBB000’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}]
    temp : [User{a=‘a0’, b=‘b0’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}]

    发现:通过Stream对List进行复制之后,对其中一个list进行修改,不会影响另一个list的值。

    展开全文
  • C#中List的浅复制和深复制

    千次阅读 2016-03-04 17:22:59
    今天在游戏中碰到一个排序问题,就是...因此需要复制出一个列表来,但是如何去复制这个列表,既能实现排序之后不会影响源列表,又要在排序之后,可以从列表中找到装备的序号。所以顺便整理了下list的各种复制的区别。

    今天在游戏中碰到一个排序问题,就是有一个装备列表,是和服务器完全一致的,各种协议需要用到装备在这个列表中的序号。但是界面显示的时候需要按照各种方式来排序,但是不能在原来的列表上排序。因此需要复制出一个列表来,但是如何去复制这个列表,既能实现排序之后不会影响源列表,又要在排序之后,可以从原列表中找到装备的序号。所以顺便整理了下list的各种复制的区别。

    源列表是List< T >

    T是值类型的情况

    浅复制:
    - List< T > oldList = new List< T >();
    - oldList.Add(..);
    - List< T > newList = oldList;

    深复制:
    - List< T > oldList = new List< T >();
    - oldList.Add(..);
    - List< T > newList = new List< T >(oldList);

    T不是值类型的情况

    T是引用或者是类的实例
    注意用List newList = oldList;这种方法不是复制,而是添加了一个引用;
    浅复制:
    1.
    - List< T > oldList = new List< T >();
    - oldList.Add(..);
    - List< T > newList = new List< T >(oldList);

    2.
    - List< T > oldList = new List< T >();
    - oldList.Add(..);
    - List< T > newList = oldList.CopyTo();

    3.
    -List< T > oldList = new List< T >();
    - oldList.Add(..);
    - List< T > newList = oldList.CopyTo();

    以上方法都可以实现类似的效果,并且复制出来的列表中的项,可以在源列表中用IndexOf之类的方法找到,所以这些也是游戏中可以用的方法,当然还有ToList()这样转换成数组的方法。除了这种复制之外,也可以用Dictionary来保存原来的键值,做一个对应。

    深复制:
    1.
    - static class Extensions
    - {
    - public static IList< T > Clone< T >(this IList< T > listToClone) where T: ICloneable
    - {
    - return listToClone.Select(item => (T)item.Clone()).ToList();
    - }
    - //当然前题是List中的对象要实现ICloneable接口
    - }

    2.也可以用序列化反序列化的方法实现深度复制,见之前的文章。

    深度复制可以完全复制出一个新的列表,用这种方法复制出来的列表里的项,是不能在原列表中找到的。

    展开全文
  • java List复制:浅拷贝与深拷贝

    千次阅读 2019-06-13 17:11:22
    List浅拷贝 众所周知,list本质上是...如上图将list A浅拷贝给list B,由于进行的是浅拷贝,所以直接将A的内容复制给了B,java中相同内容的数组指向同一地址,即进行浅拷贝后A与B指向同一地址。造成的后果就是,...
  • List集合复制的方式

    千次阅读 2017-04-19 12:43:26
    项目中遇到对List进行操作,但是需要取原List的情况,鉴于操作之后数据源已经变化 例如:List l = new ArrayList(); l.add("a"); l.add("b"); l.add("c"); List l2 = l; l2.add("d"); System.out.println(l2); ...
  • Android List之间赋值的坑(深浅复制)

    千次阅读 2019-08-05 15:56:46
    最近写了一个功能,里面有些关于list之间复制的问题,在网上查了很多最后才解决.虽然网上有很多方法了,但有些并不是能解决我的问题的,在这里做一个总结. 功能需求是从接口获取数据填充界面后,对界面进行修改,有个...
  • list中的顺序会影响list的顺序问题

    千次阅读 2016-03-21 14:39:29
    最近在看《Thinking in Java》中关于容器的章节(第11章 持有对象),有一个例子发现subList中数据顺序的改变会影响原list中数据的顺序。下面总结如下。结论 使用List.subList方法得到的子序列其实只是将指针指向...
  • 我们需要知道的是object和array类型的变量为引用类型,也就是说其存储的实际上并不是具体的值而是一个指向堆内存的地址。...有时我们并想要类似的事情发生要如任何解决呢?下面介绍两种简单的方法 ...
  • 文章目录列表元素的添加list.append()list.extend()list.insert()列表元素的删除del list[index]list.remove(obj)list.pop(index)删除重复元素通过集合(set)转换通过字典键值(key)转换使用numpy中的unique去重循环...
  • import java.util....import java.util.List; //一个实体类 public class test { public static void main(String[] args) { List x=new ArrayList(); x.add("1"); x.add("2"); System.o
  • 今天将一个 A list里面的值赋给另外一个B list之后,然后修改A list的值之后,同时把B list的的值也给修改了。 下面是例子: List<RedLightPerson> redLightPersons = redLightPersonDao.findLast(); for...
  • 在项目开发中,有一次的业务需求是需要对订单列表中信息进行处理,同时保留订单信息列表,简单直接上手撸,在对订单List<Order>中值进行操作时,最后发现复制出来的List内的对象值也同时改变。第一次写的...
  • list容器用法详解(超好用的list)-c++

    万次阅读 多人点赞 2018-10-16 10:45:47
    原创博客链接(吐槽下博客上转发这篇博客的人标明出处...找原创找了好久呜呜呜) 1.关于list容器 list是一种序列式容器。list容器完成的功能实际上和数据结构中的双向链表是极其相似的,list中的数据元素是通过...
  • python中改变listlist值的问题

    千次阅读 2016-05-27 17:04:20
    L = [] s = [0,0,0] for i in range(3): ...本意是想改变list L中一个值,使其结果为[[0,0,0],[0,1,0],[0,0,0]],但运行的结构下图所示,将list L中的所有元素都改变了。 为找到原因,查看python
  • * A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null. * Return a deep copy of the list. */给你一个链表,这个链表不仅...
  • List

    千次阅读 2019-07-21 15:48:13
    增删时,由于数组长度可变,每次都要新建一个数组,并将数组的数据复制,因此,增删慢。 ArrayList是非同步的,因此执行效率高,但在高并发时容易引起线程安全问题。 2.LinkedList linkedList底层是双向链表链表...
  • Copy List with Random Pointer 解题报告(Python) 标签(空格分隔): LeetCode 作者: 负雪明烛 id: fuxuemingzhu 个人博客: http://fuxuemingzhu.me/ 题目地址:https://leetcode.com/problems/co...
  • List的toArray方法强制转换

    万次阅读 2017-11-16 14:29:29
    因此我们可以放心的更改这些数据而不会影响原List中的数据。 当我们用toArray()方法时涉及到数据类型转换的问题,首先需要确保List内的元素是可以转换为你想转化的类型的。 该方法有两种使用形式:toArray()与
  • Java中 List、Set、Map 之间的区别

    万次阅读 多人点赞 2018-04-18 11:05:04
      List的元素以线性方式存储,可以存放重复对象,List主要有以下两个实现类: ArrayList : 长度可变的数组,可以对元素进行随机的访问,向ArrayList中插入与删除元素的速度慢。 JDK8 中ArrayList扩容的实...
  •  A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.  Return a deep copy of the list. 翻译:给定
  • 我想用递归的方法实现某些功能,但是想让方法修改传进来的list的属性 也就是说,增加元素只是在这个方法之中起作用,在其他方法中无效,请问怎么做到呢? 那个remove是我后来写上去的,但是有些...
  • 一、目标:用anaconda创建与...conda env list # 列出所有虚拟环境 有星号’*'的表示当前使用的环境,示例中root为默认环境 [root@localhost ~]# conda env list # conda environments: # tensorflow /root/anacon...
  • 自定义右键菜单——复制到粘贴板 需求: 鼠标在li标签上点击右键出现菜单,主要是复制等功能 屏蔽浏览器默认右键点击事件 右键菜单出现在鼠标点击的位置 点击屏幕其他位置菜单消失 点击之后有回调 实现: ...
  • 【143-Copy List with Random Pointer(有随机指针的链表复制)】【LeetCode-面试算法经典-Java实现】【所有题目目录索引】题 A linked list is given such that each node contains an additional random ...
  • python中list与string的转换

    万次阅读 多人点赞 2019-05-15 13:00:14
    1.list转string 命令:''.join(list) 其中,引号中是字符之间的分割符,如“,”,“;”,“\t”等等 如: list = [1, 2, 3, 4, 5] ''.join(list) 结果即为:12345 ','.join(list) 结果即为:1,2,3,4,5 str=...
  • 1 先画好图 2 注意可能形成环的情况,因此必须拆成3个循环来做 ... 一个单链表,其中除了next指针外,还有一个random指针,指向链表中的...通过next来复制一条链是很容易的,问题的难点在于如何恰当地设置新链表中的r
  • 需求:将H盘下的所有文件复制到H:/All ... 是:调用listFiles()方法,得到File数组,重点内容接着执行1 否:复制文件到H:/All 源码: package FunDemo; import java.io.File; import java.io.FileRead
  • List浅拷贝与深拷贝(解决修改新list集合,原先list数据发生变化问题)出现的问题(代码)运行结果情景一:浅拷贝(适用于list集合泛型为字符)运行结果情景二:深拷贝(适用于list集合泛型为对象)运行结果 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 138,652
精华内容 55,460
关键字:

复制list不影响原list