精华内容
下载资源
问答
  • DeepCopy

    2015-10-12 16:15:40
    DeepCopy util: import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; import net

    DeepCopy util:

    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    import net.sf.json.JSONObject;
    
    public class DeepCopy {  
        /** 
         * 深层拷贝 
         *  
         * @param <T> 
         * @param obj 
         * @return 
         * @throws Exception 
         */  
        public static <T> T copy(T obj) throws Exception {  
            //是否实现了序列化接口,即使该类实现了,他拥有的对象未必也有...  
            if(Serializable.class.isAssignableFrom(obj.getClass())){  
                //如果子类没有继承该接口,这一步会报错  
                try {  
                    return copyImplSerializable(obj);  
                } catch (Exception e) {  
                    //这里不处理,会运行到下面的尝试json  
                }  
            }  
            //如果序列化失败,尝试json序列化方式  
            if(hasJson()){  
                try {  
                    return copyByJson(obj);  
                } catch (Exception e) {  
                    //这里不处理,下面返回null  
                }  
            }  
            return null;  
        }  
      
        /** 
         * 深层拷贝 - 需要类继承序列化接口 
         * @param <T> 
         * @param obj 
         * @return 
         * @throws Exception 
         */  
        @SuppressWarnings("unchecked")  
        public static <T> T copyImplSerializable(T obj) throws Exception {  
            ByteArrayOutputStream baos = null;  
            ObjectOutputStream oos = null;  
              
            ByteArrayInputStream bais = null;  
            ObjectInputStream ois = null;  
              
            Object o = null;  
            //如果子类没有继承该接口,这一步会报错  
            try {  
                baos = new ByteArrayOutputStream();  
                oos = new ObjectOutputStream(baos);  
                oos.writeObject(obj);  
                bais = new ByteArrayInputStream(baos.toByteArray());  
                ois = new ObjectInputStream(bais);  
      
                o = ois.readObject();  
                return (T) o;  
            } catch (Exception e) {  
                throw new Exception("对象中包含没有继承序列化的对象");  
            } finally{  
                try {  
                    baos.close();  
                    oos.close();  
                    bais.close();  
                    ois.close();  
                } catch (Exception e2) {  
                    //这里报错不需要处理  
                }  
            }  
        }  
          
        /** 
         * 是否可以使用json 
         * @return 
         */  
        private static boolean hasJson(){  
            try {  
                Class.forName("net.sf.json.JSONObject");  
                return true;  
            } catch (Exception e) {  
                return false;  
            }  
        }  
          
        /** 
         * 深层拷贝 - 需要net.sf.json.JSONObject 
         * @param <T> 
         * @param obj 
         * @return 
         * @throws Exception 
         */  
        @SuppressWarnings("unchecked")  
        public static <T> T copyByJson(T obj) throws Exception {  
            return (T)JSONObject.toBean(JSONObject.fromObject(obj),obj.getClass());  
        }  
    }


    调用:

    preFpd = DeepCopy.copy(fpd);

    对象需要implement Serializable:

    public class Fpd implements Serializable {
    	
    	private static final long serialVersionUID = 1L;
    	// ...

    参考:

    http://blog.csdn.net/isea533/article/details/9375907

    展开全文
  • deepCopy

    2008-01-12 21:29:00
     public static Object deepCopy(Serializable obj) throws IOException, ClassNotFoundException {  if (obj == null) {  // 引数がnullの場合  return null;  }  // Serializableを実装したClassのディープ...

    /**
      * 引数のオブジェクトのディープコピーを返却します。
      * ※コピー元のオブジェクトおよび、その要素はjava.io.Serializableを実装する必要があります。
      * @param obj コピー元オブジェクト
      * @return 引数のディープコピー
      * @throws IOException
      * @throws ClassNotFoundException
      */
     public static Object deepCopy(Serializable obj) throws IOException, ClassNotFoundException {
      if (obj == null) {
       // 引数がnullの場合
       return null;
      }
      // Serializableを実装したClassのディープコピーを作成し、返却する。
      ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
      ObjectOutputStream out = new ObjectOutputStream(byteOut);
      out.writeObject(obj);
      ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
      ObjectInputStream in = new ObjectInputStream(byteIn);
      return in.readObject();
     }
     

    法案②

    public class ob implements Cloneable {
     
     public ob(){}
     public Object clone() {
      try {
       return super.clone() ;
      } catch (CloneNotSupportedException e) {
       throw new InternalError(e.getMessage());
      }
     
     }

    展开全文
  • deepcopy

    2007-04-26 11:34:00
    实现思想: 对象-〉序列化-〉二进制流-〉反序列化-〉新的对象DotNet 代码: public static Object DeepClone(Object srcObject) { //定义内存流 MemoryStream ms=new MemoryStream(); //定义二进制流 
     
    

    实现思想:  对象-〉序列化-〉二进制流-〉反序列化-〉新的对象

    DotNet 代码:

        public static  Object DeepClone(Object srcObject)
          {
               //定义内存流
               MemoryStream ms=new MemoryStream();
               //定义二进制流
               IFormatter bf=new BinaryFormatter();
               //序列化
               bf.Serialize(ms,srcObject);
               //重置指针到起始位置,以备反序列化
               ms.Position=0;
               //返回反序列化的深克隆对象
               return bf.Deserialize(ms);

          } 

     
    展开全文
  • Python---copy()、deepcopy()与赋值的区别

    万次阅读 多人点赞 2017-11-22 16:04:35
    copy()与deepcopy()之间的主要区别是python对数据的存储方式。 首先直接上结论: —–我们寻常意义的复制就是深复制,即将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对已经...

    copy()与deepcopy()之间的主要区别是python对数据的存储方式。

    首先直接上结论:

    —–深复制即将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对已经复制出来的新对象产生影响。 

    —–而等于赋值,并不会产生一个独立的对象单独存在,他只是将原有的数据块打上一个新标签,所以当其中一个标签被改变的时候,数据块就会发生变化,另一个标签也会随之改变。

    —–而浅复制要分两种情况进行讨论:

    1)当浅复制的值是不可变对象(数值,字符串,元组)和“等于赋值”的情况一样,对象的id值与浅复制原来的值相同。

    2)当浅复制的值是可变对象(列表和元组)时会产生一个“不是那么独立的对象”存在。有两种情况:

    第一种情况:复制的 对象中无 复杂 子对象,原来值的改变并不会影响浅复制的值,同时浅复制的值改变也并不会影响原来的值。原来值的id值与浅复制原来的值不同。

    第二种情况复制的对象中有 复杂 子对象 (例如列表中的一个子元素是一个列表),如果不改变其中复杂子对象浅复制的值改变并不会影响原来的值。 但是改变原来的值 中的复杂子对象的值  会影响浅复制的值

    对于简单的 object,例如不可变对象(数值,字符串,元组),用 shallow copy 和 deep copy 没区别

    复杂的 object, 如 list 中套着 list 的情况,shallow copy 中的 子list,并未从原 object 真的「独立」出来。也就是说,如果你改变原 object 的子 list 中的一个元素,你的 copy 就会跟着一起变。这跟我们直觉上对「复制」的理解不同。

    当浅复制的值是不可变对象(数值,字符串,元组)时,代码如下:

    >>> a="1234567"
    >>> b=a
    >>> id(a)
    4367619440
    >>> id(b)
    4367619440
    >>> c=copy.copy(a)
    >>> id(c)
    4367619440
    >>> d=copy.deepcopy(a)
    >>> id(d)
    4367619440

     

    浅复制的值是可变对象(列表,字典)时,改变的值不是 复杂子对象 代码如下:

    >>> l1=[1,2,3]
    >>> l2=l1
    >>> l3=copy.copy(l1)
    >>> id(l1)
    4367654664
    >>> id(l2)
    4367654664
    >>> id(l3)
    4367628616
    >>> l1.append(55)
    >>> print(l1)
    [1, 2, 3, 55]
    >>> print(l3)
    [1, 2, 3]
    
    

    当浅复制的值是可变对象(列表,字典)时,改变的值是 复杂子对象 代码如下:

    >>> import copy
    >>> list1=[1,2,['a','b']]
    >>> list2=list1
    >>> list3=copy.copy(list2)
    >>> list4=copy.deepcopy(list3)
    >>> id(list1)
    4338414656
    >>> id(list2)
    4338414656
    >>> id(list3)
    4338415016
    >>> id(list4)
    4338414368
    >>> list1[2].append('a')
    >>> id(list1)
    4338414656
    >>> print list1
    [1, 2, ['a', 'b', 'a']]
    >>> print list3
    [1, 2, ['a', 'b', 'a']]
    >>> print list4
    [1, 2, ['a', 'b']]
    >>> list1.append(33)
    >>> id(list1)
    4338414656
    >>> id(list3)
    4338415016
    >>> print list1
    [1, 2, ['a', 'b', 'a'], 33]
    >>> print list3
    [1, 2, ['a', 'b', 'a']]


    代码说明:当改变 复杂子对象中的元素时,浅复制值发生了变化; 当改变的值不是复杂子对象,浅复制的值没有发生变化。因为 浅复制 ,复杂子对象的保存方式是 作为 引用 方式存储的,所以修改 浅复制的值 和原来的值都可以 改变 复杂子对象的值。

     

    python的数据存储方式

    Python 存储变量的方法跟其他 OOP 语言不同。它与其说是把值赋给变量,不如说是给变量建立了一个到具体值的 reference。

    当在 Python 中 a = something 应该理解为给 something 贴上了一个标签 a。当再赋值给 a 的时候,就好象把 a 这个标签从原来的 something 上拿下来,贴到其他对象上,建立新的 reference。 这就解释了一些 Python 中可能遇到的诡异情况:

    >> a = [1, 2, 3]
    >>> b = a
    >>> a = [4, 5, 6] //赋新的值给 a
    >>> a
    [4, 5, 6]
    >>> b
    [1, 2, 3]
    # a 的值改变后,b 并没有随着 a 变
    
    >>> a = [1, 2, 3]
    >>> b = a
    >>> a[0], a[1], a[2] = 4, 5, 6 //改变原来 list 中的元素
    >>> a
    [4, 5, 6]
    >>> b
    [4, 5, 6]
    # a 的值改变后,b 随着 a 变了

    上面两段代码中,a 的值都发生了变化。区别在于,第一段代码中是直接赋给了 a 新的值(从 [1, 2, 3] 变为 [4, 5, 6]);而第二段则是把 list 中每个元素分别改变。而对 b 的影响则是不同的,一个没有让 b 的值发生改变,另一个变了。怎么用上边的道理来解释这个诡异的不同呢?首次把 [1, 2, 3] 看成一个物品。a = [1, 2, 3] 就相当于给这个物品上贴上 a 这个标签。而 b = a 就是给这个物品又贴上了一个 b 的标签。 

     
    第一种情况:a = [4, 5, 6] 就相当于把 a 标签从 [1 ,2, 3] 上撕下来,贴到了 [4, 5, 6] 上。在这个过程中,[1, 2, 3] 这个物品并没有消失。 b 自始至终都好好的贴在 [1, 2, 3] 上,既然这个 reference 也没有改变过。 b 的值自然不变。

     
     

    第二种情况:a[0], a[1], a[2] = 4, 5, 6 则是直接改变了 [1, 2, 3] 这个物品本身。把它内部的每一部分都重新改装了一下。内部改装完毕后,[1, 2, 3] 本身变成了 [4, 5, 6]。而在此过程当中,a 和 b 都没有动,他们还贴在那个物品上。因此自然 a b 的值都变成了 [4, 5, 6]。

    搞明白这个之后就要问了,对于一个复杂对象的浅copy,在copy的时候到底发生了什么? 
    再看一段代码:

    >>> import copy
    >>> origin = [1, 2, [3, 4]]
    #origin 里边有三个元素:1, 2,[3, 4]
    >>> cop1 = copy.copy(origin)
    >>> cop2 = copy.deepcopy(origin)
    >>> cop1 == cop2
    True
    >>> cop1 is cop2
    False 
    #cop1 和 cop2 看上去相同,但已不再是同一个object
    >>> origin[2][0] = "hey!" 
    >>> origin
    [1, 2, ['hey!', 4]]
    >>> cop1
    [1, 2, ['hey!', 4]]
    >>> cop2
    [1, 2, [3, 4]]
    #把origin内的子list [3, 4] 改掉了一个元素,观察 cop1 和 cop2

     

    学过docker的人应该对镜像这个概念不陌生,我们可以把镜像的概念套用在copy上面。

     

    copy(浅复制)对于一个复杂对象的子对象并不会完全复制,什么是复杂对象的子对象呢?就比如序列里的嵌套序列字典里的嵌套序列等都是复杂对象的子对象。对于子对象,python会把它当作一个公共镜像存储起来,所有对他的复制都被当成一个引用,所以说当其中一个引用将镜像改变了之后另一个引用使用镜像的时候镜像已经被改变了

    所以说看这里的origin[2],也就是 [3, 4] 这个 list。根据 shallow copy 的定义,在 cop1[2] 指向的是同一个 list [3, 4]。那么,如果这里我们改变了这个 list,就会导致 origin 和 cop1 同时改变。这就是为什么上边 origin[2][0] = “hey!” 之后,cop1 也随之变成了 [1, 2, [‘hey!’, 4]]。

     

    deepcopy的时候会将复杂对象的每一层复制一个单独的个体出来。 
    这时候的 origin[2] 和 cop2[2] 虽然值都等于 [3, 4],但已经不是同一个 list了。即我们寻常意义上的复制。

     

    “无意中发现了一个巨牛的人工智能教程,忍不住分享一下给大家。教程不仅是零基础,通俗易懂,而且非常风趣幽默,像看小说一样!觉得太牛了,所以分享给大家。点这里可以跳转到教程。”

     

    展开全文
  • DeepCopy-ShallowCopy:DeepCopy&ShallowCopy
  • deepcopy fails

    2020-12-01 15:54:10
    t seem to deepcopy a loaded 1-port Network. I don't have the time now to set up a test that detects the bug and then fix it. Furthermore, I have a problem configuring git for our corporate proxy, ...
  • DeepCopy Performance

    2020-11-30 07:47:25
    <div><p>It seems that DeepCopy is very, very slow in cloning objects. <p>Here is a screenshot of a cachegrind report with DeepCopy enabled: <p><img alt="bildschirmfoto 2016-11-22 um 16 45 03" src=...
  • Added deepCopy

    2020-12-26 04:32:41
    <div><p>deepCopy will create a shallow copy of an object, and will recursively create shallow copies of any other referenced object. </p><p>该提问来源于开源项目:matthewcheok/Realm-JSON</p></div...
  • NSDictionary deepCopy

    2018-07-25 15:51:00
    @interface NSDictionary (DeepCopy)   -(NSMutableDictionary *)deepCopy;   @end   @implementation NSDictionary (DeepCopy)   -(NSDictionary *)deepCopy {  NSMutableDictionary *dictionary = ....
  • ../../../anaconda/lib/python3.4/copy.py:182: in deepcopy y = _reconstruct(x, rv, 1, memo) ../../../anaconda/lib/python3.4/copy.py:300: in _reconstruct state = deepcopy(state, memo) ../../../...
  • Deepcopy for updates

    2020-12-08 23:46:37
    <div><p>...<p>I see no deepcopy objects being used. Can we use deepcopy here ?</p><p>该提问来源于开源项目:pravega/zookeeper-operator</p></div>
  • Python DeepCopy

    2019-09-15 12:56:30
    Copy 和 DeepCopy的区别。 Ppython中所有数据类型都是对象,变量名只是一个对象的引用(标签)。 copy: 不可变对象:相当于增加了一个对象引用(新标签),包括简单数据类型和Tuple,Set >>> a = 123 ...
  • python deepcopy

    2019-04-15 16:36:05
    1. copy.copy 浅拷贝 只...2. copy.deepcopy 深拷贝 拷贝对象及其子对象一个很好的例子: import copya = [1, 2, 3, 4, ['a', 'b']]  #原始对象b = ...
  • <div><p>The behavior when calling <code>DeepCopy()</code> on a <code>List<Resource></code> (i.e. by using <code>ListCopyExtensions.DeepCopy) violates the principle of least surprise and could ...
  • 对象deepcopy

    2018-10-23 17:37:00
    export const deepCopy = (dst, ori) => { let keys = Object.keys(ori) keys.forEach((key) => { if (typeof ori[key] === 'object') { if (Array.isArray(ori[key])) { ...
  • return copy.deepcopy(reset_cache_bijectors(input_module), memo) File "/home/elvijs/.virtualenvs/automl_res/lib/python3.7/copy.py", line 180, in deepcopy y = _reconstruct(x, memo, *rv) ...
  • deepcopy Model object

    2020-12-08 21:07:44
    <p>is there a way to deepcopy a Model object, e.g. to implement a primal heuristic based on a subMIP. <p>Best regards & thanks, Markus</p><p>该提问来源于开源项目:scipopt/PySCIPOpt</p></div>
  • copy deepcopy

    2017-03-21 17:54:43
    deepcopy会产生独立的对象,原对象只改变不影响复制对象 对于简单的对象而言,两者是没有区别的 对于复杂对象而言,区别会体现出来。例如: import copy a = [1, 2, 3, [1, 2, 3]] b=copy.copy(a) c=copy....
  • VTK:Utilities之DeepCopy

    2021-05-09 20:53:54
    VTK:Utilities之DeepCopyVTK:Utilities之DeepCopy代码DeepCopy.cxxCMakeLists.txt VTK:Utilities之DeepCopy 代码 DeepCopy.cxx #include <vtkNew.h> #include <vtkPolyData.h> int main(int, char*...
  • copy和deepcopy

    2020-09-20 08:58:26
    deepcopy原内容改变,赋值对象不会改变 deepcopy会新开辟一个内存空间 代码 num1 = 1 num2 = num1.copy() print(num2) num1 = 2 print("*"*100) print(num2) num3 = 3 num4 = num1.deepcopy() print(num4) num3 = 4 ...
  • Fix deepcopy edge cases

    2020-12-04 12:31:56
    <p>deepcopy uses the <code>__deepcopy__</code> method or if not present <code>__getstate__, <code>__setstate__</code> methods. I added custom <code>__getstate__/__setstate__</code> methods in Stats ...
  • deepcopy causes memory copy

    2020-12-09 05:15:10
    copy.deepcopy(self) <p>deepcopy is causing a memory copy and crashes. I tried to implement a fix that only deepcopies the relevant words, but for some reason this is not working. Are there any ideas?...
  • 错误(活动) E0289 没有与参数列表匹配的构造函数 “deepCopy::deepCopy” 实例 deepCopyDemo    class deepCopy { public:  // deepCopy(int deepNo1, char *deepStr1) deepCopy(int deepNo1, const char *...
  • 仅出于教育目的,我尝试实现copy.deepcopy()的克隆函数。在在玩了一番代码并在谷歌上搜索之后,我想出了以下函数:def my_deepcopy(data):if isinstance(data, dict):result = {}for key, value in data.items():...
  • Deepcopy Network object fail

    2020-12-08 22:27:34
    from copy import deepcopy network = Network() network2 = deepcopy(network) print (network3.to_data()) </code></pre> <p><strong>Error:</strong> 'Network' object has no attribute '...
  • DeepCopy not copying objects

    2020-11-28 23:46:41
    <div><p>I’m using deepCopy() from dojo/request/util to try to make a copy of an object that’s independent of the original object. To do this I’m using the format var newOjb = util.deepCopy({}, ...
  • <div><p>According to the discussion on Slack, we choose to make <code>protoc-gen-deepcopy</code> generate deepcopy methods for all types in the package. <p>Remain question: 1. ~~the tag <code>+...
  • python实现deepcopy

    2019-02-12 22:57:54
    def deepCopy(src): if isinstance(src, dict): dst = {} for k,v in src.items(): dst[k] = deepCopy(v) return dst elif isinstance(src, list or tuple): ...
  • deepcopy.js 深度复制数据 安装 npm $ npm install deepcopy 用法 node.js JavaScript const deepcopy = require ( 'deepcopy' ) ; 打字稿 import * as deepcopy from 'deepcopy' ; 浏览器 < script src =" ...
  • 方法实现很简单,提供两种方式:一种是序列化成数据流,前提是所有对象(对象中包含的对象...)都需要继承Serializable接口,如果都继承了那很容易,如果没有继承,...具体代码如下:public class DeepCopy {/*** 深...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,534
精华内容 1,813
关键字:

deepcopy