精华内容
下载资源
问答
  • java复制对象

    万次阅读 2012-03-14 17:31:53
    关于java对象复制 我们在编码过程经常会碰到将一个对象传递给另一个对象java中对于基本型变量 采用的是值传递,而对于对象比如bean传递时采用的是应用传递也就是地址传递, 而很多时候对于对象传递我们也希望...
    关于java对象复制
    我们在编码过程经常会碰到将一个对象传递给另一个对象,java中对于基本型变量
    采用的是值传递,而对于对象比如bean传递时采用的是应用传递也就是地址传递,
    而很多时候对于对象传递我们也希望能够象值传递一样,使得传递之前和之后有
    不同的内存地址,在这种情况下我们一般采用以下两种情况。

    1 对象克隆
    什么是"clone"?


    在实际编程过程中,我们常常要遇到这种情况:有一个对象A,在某一时刻A中已经包含了一些有效值,此时可能会需要一个和A完全相同新对象B,并且此后对B任何改动都不会影响到A中的值,也就是说,A与B是两个独立的对象,但B的初始值是由A对象确定的。在Java语言中,用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径,但实现clone()方法是其中最简单,也是最高效的手段。

    Java的所有类都默认继承java.lang.Object类,在java.lang.Object类中有一个方法clone()。JDK API的说明文档解释这个方法将返回Object对象的一个拷贝。要说明的有两点:一是拷贝对象返回的是一个新对象,而不是一个引用。二是拷贝对象与用new操作符返回的新对象的区别就是这个拷贝已经包含了一些原来对象的信息,而不是对象的初始信息。

    怎样应用clone()方法?


    一个很典型的调用clone()代码如下:

    class CloneClass implements Cloneable{
        public int aInt;
        public Object clone(){
            CloneClass o = null;
            try{
                o = (CloneClass)super.clone();
            }catch(CloneNotSupportedException e){
                e.printStackTrace();
            }
            return o;
        }





    有三个值得注意的地方,一是希望能实现clone功能的CloneClass类实现了Cloneable接口,这个接口属于java.lang包,java.lang包已经被缺省的导入类中,所以不需要写成java.lang.Cloneable。另一个值得请注意的是重载了clone()方法。最后在clone()方法中调用了super.clone(),这也意味着无论clone类的继承结构是什么样的,super.clone()直接或间接调用了java.lang.Object类的clone()方法。下面再详细的解释一下这几点。

    应该说第三点是最重要的,仔细观察一下Object类的clone()一个native方法,native方法的效率一般来说都是远高于java中的非native方法。这也解释了为什么要用Object中clone()方法而不是先new一个类,然后把原始对象中的信息赋到新对象中,虽然这也实现了clone功能。对于第二点,也要观察Object类中的clone()还是一个protected属性的方法。这也意味着如果要应用clone()方法,必须继承Object类,在Java中所有的类是缺省继承Object类的,也就不用关心这点了。然后重载clone()方法。还有一点要考虑的是为了让其它类能调用这个clone类的clone()方法,重载之后要把clone()方法的属性设置为public。

    那么clone类为什么还要实现Cloneable接口呢?稍微注意一下,Cloneable接口是不包含任何方法的!其实这个接口仅仅是一个标志,而且这个标志也仅仅是针对Object类中clone()方法的,如果clone类没有实现Cloneable接口,并调用了Object的clone()方法(也就是调用了super.Clone()方法),那么Object的clone()方法就会抛出CloneNotSupportedException异常。

    什么是影子clone?


    下面的例子包含三个类UnCloneA,CloneB,CloneMain。CloneB类包含了一个UnCloneA的实例和一个int类型变量,并且重载clone()方法。CloneMain类初始化UnCloneA类的一个实例b1,然后调用clone()方法生成了一个b1的拷贝b2。最后考察一下b1和b2的输出:

    package clone;
    class UnCloneA {
        private int i;
        public UnCloneA(int ii) { i = ii; }
        public void doubleValue() { i *= 2; }
        public String toString() {
            return Integer.toString(i);
        }
    }
    class CloneB implements Cloneable{
        public int aInt;
        public UnCloneA unCA = new UnCloneA(111);
        public Object clone(){
            CloneB o = null;
            try{
                o = (CloneB)super.clone();
            }catch(CloneNotSupportedException e){
                e.printStackTrace();
            }
            return o;
        }
    }
    public class CloneMain {
        public static void main(String[] a){
            CloneB b1 = new CloneB();
            b1.aInt = 11;
            System.out.println("before clone,b1.aInt = "+ b1.aInt);
            System.out.println("before clone,b1.unCA = "+ b1.unCA);
                    
            CloneB b2 = (CloneB)b1.clone();
            b2.aInt = 22;
            b2.unCA.doubleValue();
            System.out.println("=================================");
            System.out.println("after clone,b1.aInt = "+ b1.aInt);
            System.out.println("after clone,b1.unCA = "+ b1.unCA);
            System.out.println("=================================");
            System.out.println("after clone,b2.aInt = "+ b2.aInt);
            System.out.println("after clone,b2.unCA = "+ b2.unCA);
        }
    }


    /** RUN RESULT:
    before clone,b1.aInt = 11
    before clone,b1.unCA = 111
    =================================
    after clone,b1.aInt = 11
    after clone,b1.unCA = 222
    =================================
    after clone,b2.aInt = 22
    after clone,b2.unCA = 222
    */





    输出的结果说明int类型的变量aInt和UnCloneA的实例对象unCA的clone结果不一致,int类型是真正的被clone了,因为改变了b2中的aInt变量,对b1的aInt没有产生影响,也就是说,b2.aInt与b1.aInt已经占据了不同的内存空间,b2.aInt是b1.aInt的一个真正拷贝。相反,对b2.unCA的改变同时改变了b1.unCA,很明显,b2.unCA和b1.unCA是仅仅指向同一个对象的不同引用!从中可以看出,调用Object类中clone()方法产生的效果是:先在内存中开辟一块和原始对象一样的空间,然后原样拷贝原始对象中的内容。对基本数据类型,这样的操作是没有问题的,但对非基本类型变量,我们知道它们保存的仅仅是对象的引用,这也导致clone后的非基本类型变量和原始对象中相应的变量指向的是同一个对象。

    大多时候,这种clone的结果往往不是我们所希望的结果,这种clone也被称为"影子clone"。要想让b2.unCA指向与b2.unCA不同的对象,而且b2.unCA中还要包含b1.unCA中的信息作为初始信息,就要实现深度clone。

    怎么进行深度clone?


    把上面的例子改成深度clone很简单,需要两个改变:一是让UnCloneA类也实现和CloneB类一样的clone功能(实现Cloneable接口,重载clone()方法)。二是在CloneB的clone()方法中加入一句o.unCA = (UnCloneA)unCA.clone();

    程序如下:

    package clone.ext;
    class UnCloneA implements Cloneable{
        private int i;
        public UnCloneA(int ii) { i = ii; }
        public void doubleValue() { i *= 2; }
        public String toString() {
            return Integer.toString(i);
        }
        public Object clone(){
            UnCloneA o = null;
            try{
                o = (UnCloneA)super.clone();
            }catch(CloneNotSupportedException e){
                e.printStackTrace();
            }
            return o;
        }
    }
    class CloneB implements Cloneable{
        public int aInt;
        public UnCloneA unCA = new UnCloneA(111);
        public Object clone(){
            CloneB o = null;
            try{
                o = (CloneB)super.clone();
            }catch(CloneNotSupportedException e){
                e.printStackTrace();
            }
            o.unCA = (UnCloneA)unCA.clone();
            return o;
        }
    }
    public class CloneMain {
        public static void main(String[] a){
            CloneB b1 = new CloneB();
            b1.aInt = 11;
            System.out.println("before clone,b1.aInt = "+ b1.aInt);
            System.out.println("before clone,b1.unCA = "+ b1.unCA);
                    
            CloneB b2 = (CloneB)b1.clone();
            b2.aInt = 22;
            b2.unCA.doubleValue();
            System.out.println("=================================");
            System.out.println("after clone,b1.aInt = "+ b1.aInt);
            System.out.println("after clone,b1.unCA = "+ b1.unCA);
            System.out.println("=================================");
            System.out.println("after clone,b2.aInt = "+ b2.aInt);
            System.out.println("after clone,b2.unCA = "+ b2.unCA);
        }
    }

    /** RUN RESULT:
    before clone,b1.aInt = 11
    before clone,b1.unCA = 111
    =================================
    after clone,b1.aInt = 11
    after clone,b1.unCA = 111
    =================================
    after clone,b2.aInt = 22
    after clone,b2.unCA = 222
    */





    可以看出,现在b2.unCA的改变对b1.unCA没有产生影响。此时b1.unCA与b2.unCA指向了两个不同的UnCloneA实例,而且在CloneB b2 = (CloneB)b1.clone();调用的那一刻b1和b2拥有相同的值,在这里,b1.i = b2.i = 11。

    要知道不是所有的类都能实现深度clone的。例如,如果把上面的CloneB类中的UnCloneA类型变量改成StringBuffer类型,看一下JDK API中关于StringBuffer的说明,StringBuffer没有重载clone()方法,更为严重的是StringBuffer还是一个final类,这也是说我们也不能用继承的办法间接实现StringBuffer的clone。如果一个类中包含有StringBuffer类型对象或和StringBuffer相似类的对象,我们有两种选择:要么只能实现影子clone,要么就在类的clone()方法中加一句(假设是SringBuffer对象,而且变量名仍是unCA): o.unCA = new StringBuffer(unCA.toString()); //原来的是:o.unCA = (UnCloneA)unCA.clone();

    还要知道的是除了基本数据类型能自动实现深度clone以外,String对象是一个例外,它clone后的表现好象也实现了深度clone,虽然这只是一个假象,但却大大方便了我们的编程。

    通过以上我们可以看出在某些情况下,我们可以利用clone方法来实现对象只见的复制,但对于比较复杂的对象(比如对象中包含其他对象,其他对象又包含别的对象.....)这样我们必须进行层层深度clone,每个对象需要实现cloneable接口,比较麻烦,那就继续学习下一个序列化方法。

    2 对象序列化

    所谓对象序列化就是将对象的状态转换成字节流,以后可以通过这些值再生成相同状态的对象。这个过程也可以通过网络实现,可以先在Windows机器上创建一个对象,对其序列化,然后通过网络发给一台Unix机器,然后在那里准确无误地重新“装配”。是不是很神奇。

    也许你会说,只了解一点点,但从来没有接触过,其实未必如此。RMI、Socket、JMS、EJB你总该用过一种吧,彼此为什么能够传递Java对象,当然都是对象序列化机制的功劳。

    第一次使用Java的对象序列化是做某项目,当时要求把几棵非常复杂的树(JTree)及相应的数据保存下来(就是我们常用的保存功能),以便下次运行程序时可以继续上次的操作。

    那时XML技术在网上非常的热,而且功能也强大,再加上树的结构本来就和XML存储数据的格式很像。作为一项对新技术比较有兴趣的我当然很想尝试一下。不过经过仔细分析,发现如果采用XML保存数据,后果真是难以想象:哪棵树的哪个节点被展开、展开到第几级、节点当前的属性是什么。真是不知该用A、B、C还是用1、2、3来表示。

    还好,发现了Java的对象序列化机制,问题迎刃而解,只需简单的将每棵树的根节点序列化保存到硬盘上,下次再通过反序列化后的根节点就可以轻松的构造出和原来一模一样的树来。

    其实保存数据,尤其是复杂数据的保存正是对象序列化的典型应用。最近另一个项目就遇到了需要对非常复杂的数据进行存取,通过使用对象的序列化,问题同样化难为简。

    来自:

    http://liran-email.iteye.com/blog/550249



    对象的序列化还有另一个容易被大家忽略的功能就是对象复制(Clone),Java中通过Clone机制可以复制大部分的对象,但是众所周知,Clone有深层Clone和浅层Clone,如果你的对象非常非常复杂,假设有个100层的Collection(夸张了点),如果你想实现深层Clone,真是不敢想象,如果使用序列化,不会超过10行代码就可以解决。

    还有就是Swing组件,如果你有两个很象很象(或是一模一样)的比较难以构造的Swing组件,你该怎么办,也许你想到了Clone,但是偏偏Java的Swing组件没有提供Clone方法。别急,使用序列化,6行代码搞定:

    ByteArrayOutputStream
    byteOut = new ByteArrayOutputStream(); 
    ObjectOutputStream out
    = new ObjectOutputStream(byteOut); 
    out.writeObject(combo); 

    ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray()); 
    ObjectInputStream in
    =new ObjectInputStream(byteIn); 
    JComboBox comb2 = (JComboBox)in.readObject();


    虽然Java的序列化非常简单、强大,但是要用好,还有很多地方需要注意。比如曾经序列化了一个对象,可由于某种原因,该类做了一点点改动,然后重新被编译,那么这时反序列化刚才的对象,将会出现异常。 

    你可以通过添加serialVersionUID属性来解决这个问题。如果你的类是个单态(Singleton)类,是否允许用户通过序列化机制复制该类,如果不允许你需要谨慎对待该类的实现。 


        /**
         * Clone Object
         * @param obj
         * @return
         * @throws Exception
         */
        private Object cloneObject(Object obj) throws Exception{
            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();
        }

    参考资料:

    1.http://www-128.ibm.com/developerworks/cn/java/l-jpointer/index.html

    2.http://www.softexam.cn/eschool/details.asp?id=10930
    展开全文
  • Java复制对象与集合工具类

    千次阅读 2019-03-31 19:13:04
    项目中经常需要将某个对象的属性值复制给另一个对象,或者将一个集合复制到另一个集合。利用spring提供的BeanUtils,自己简单封装了一个工具类。 public class CopyUtils { /** * 复制集合 */ public static &...

    项目中经常需要将某个对象的属性值复制给另一个对象,或者将一个集合复制到另一个集合。利用spring提供的BeanUtils,自己简单封装了一个工具类。

    public class CopyUtils {
    
        /**
         * 复制集合
         */
        public static <T,K> List<T> copyList(List<K> sourceList, Class<T> clazz) {
            if (CollectionUtils.isEmpty(sourceList)) {
                return null;
            }
    
            ArrayList<T> target = new ArrayList<>();
            sourceList.forEach(k -> target.add(convert(k, clazz)));
            return target;
        }
    
        /**
         * 复制对象
         */
        public static <T,K> T convert(K source, Class<T> clazz) {
            T t = BeanUtils.instantiate(clazz);
            BeanUtils.copyProperties(source, t);
            return t;
        }
    
    }
    
    展开全文
  • 大家在日常的java开发中,经常会使用到对象之间属性的赋值操作,如果两个对象之间复制的属性不多的时候,我们一般都会使用java提供的get、set方法进行复制。但是碰到对象的属性数量特别多的时候(业务代码对象动辄几...

      大家在日常的java开发中,经常会使用到对象之间属性的赋值操作,如果两个对象之间复制的属性不多的时候,我们一般都会使用java提供的get、set方法进行复制。但是碰到对象的属性数量特别多的时候(业务代码对象动辄几十上百个属性),属性复制手工输入上百个get、set将会特别耗时耗力。
      如何使用一句简单的代码直接复制上百个属性,这里介绍几种常用的方法,以及本人在实际项目中碰到的一个坑。

    1. 使用org.apache.commons.beanutils.BeanUtils.copyProperties(Object
      dest, Object orig); dest目标对象,orig源对象。(这个方法比较坑,耗时严重,之后介绍)
    2. 使用org.springframework.beans.BeanUtils.copyProperties(Object source,
      Object target); source源对象,target对象。(注意和apache的是反过来的) 1.
    3. 使用net.sf.cglib.beans.BeanCopier.copy(from, to, null);
      先定义BeanCopier beanCopier =BeanCopier.create(“要转换的类”, “转换后的类”, false);   再复制beanCopier.copy(from, to, null);
    4. org.springframework.cglib.beans.BeanCopier.copy(from, to, null);
      先定义BeanCopier beanCopier =BeanCopier.create(“要转换的类”, “转换后的类”, false);   再进行复制beanCopier.copy(from, to, null);

        
        本人做了简单的测试,如下:
        JAVA对象复制对比测试
        可以发现org.apache.commons.beanutils.BeanUtils.copyProperties在属性多的情况复制效率严重低下,本人曾使用这个方法也被坑惨了。
        推荐使用spring的beanUtils或者BeanCopier,使用简单方便,效率较高,上百行的属性复制一行搞定,轻松愉快。
        本人也是做了简单的测试,还有其他的坑估计还要进行进一步深入探索。

    展开全文
  • JAVA复制对象给另一个对象

    千次阅读 2016-06-25 22:40:15
    JAVA复制对象给另一个对象  标签: javahibernateobject 2012-03-23 16:46 14881人阅读 评论(0) 收藏 举报  分类:   J2SE(113)  版权声明:本文为博主原创文章,未经博主允许...
     

    JAVA复制对象给另一个对象 

    标签: javahibernateobject
     14881人阅读 评论(0) 收藏 举报
     分类:
     

    今天算是遇到一个问题了。相当苦恼。

    需求如下:有2个相同id的对象,但它们的值不同。其中一个对象要用到另一个对象的属性值。

    由于在hibernate的sessionFactory().getSession中不能存在2个相同id的对象。故此,想出复制对象。

    找了很多地方,发现有2种方法可以达到复制对象的目的,只是最后这种方法还是没有解决我的问题。仅此记下来吧。

    1,克隆clone

    Java支持克隆一个对象的值到另一个对象,简单的克隆和深度克隆,深度克隆可能包括继承,嵌套,没有用到,所以也就没怎么去研究它。

    首先,克隆的对象需要实现 Cloneable接口,重写其中的clone()方法,为了使clone()方法在外部可用,需要将重写的方法访问修饰符改成public级别。

    [java] view plain copy
     print?
    1. @Override  
    2.     public Object clone() throws CloneNotSupportedException {  
    3.         return super.clone();  
    4.     }  

    [java] view plain copy
     print?
    1. dv=(Deliverymanreport)deliverymanreport.clone();//克隆对象  

    dv是deliverymanreport克隆的一个对象。它拥用克隆后的属性和方法。


    2,序列化和反序列化Serializable

    序列化的对象要实现Serializable接口才能实现序列化。

    序列化后,通过反序列化可以得到和当前对象一样的对象。它比克隆来得更准备。但也就不一定最好,如果这个对象在之前被修改,序列化后可能就会出问题了。

    [java] view plain copy
     print?
    1. ByteArrayOutputStream byteOut = new ByteArrayOutputStream();  
    2. ObjectOutputStream out= new ObjectOutputStream(byteOut);  
    3. out.writeObject(deliverymanreport);//写对象,序列化  
    4. ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());   
    5.  dv=(Deliverymanreport)in.readObject(); //读对象,反序列化  

    序列化经常用于文件传递的读取。尤其是在缓存中用得比较多,通过序列化可以将对象缓存在硬盘中。这在登录系统缓存用户权限和角色等信息最常见。而用对克隆对象,也不失为一种很好的方法。
    展开全文
  • Java 对象的生命周期包括创建、使用和清除,本文详细介绍对象的创建,在 Java 语言中创建对象分显式创建与隐含创建两种情况。 显式创建对象 对象的显式创建方式有 4 种。 1. 使用 new 关键字创建对象 这是常用的创建...
  • java 一般方法复制list对象

    千次阅读 2014-09-11 10:28:02
    import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.i
  • java 复制非空对象属性值

    千次阅读 2017-02-15 11:31:27
    用于对象拷贝,spring 和 Apache都提供了相应的工具类方法,BeanUtils.copyProperties 但是对于非空属性拷贝就需要自己处理了 在这里借用spring中org.springframework.beans.BeanUtils类提供的方
  • Java如何复制对象

    万次阅读 多人点赞 2013-01-10 21:29:38
    假如说你想复制一个简单变量。很简单: int apples = 5; int pears = apples; ...不仅仅是int类型,其它七种...但是如果你复制的是一个对象,情况就有些复杂了。 假设说我是一个beginner,我会这样写: c
  • java Map 复制对象复制

    万次阅读 2016-10-26 14:55:16
    A:浅复制(浅克隆): 浅复制仅仅复制所考虑的对象,而不复制它所引用的对象。  b:深复制(深克隆):深复制把要复制对象所引用的对象复制了一遍。  序列化和反序列化 Serializable 序列化的对象...
  • Android或java对象复制

    千次阅读 2019-06-27 17:51:37
    为何要复制对象, 在此就不做细数, 下面简单说明文字+代码. 对象复制, 总体来将, 分为三种方法. 方法一: 用getter和setter挨个进行赋值, 这种方式简单, 但实际用起来比较麻烦.. 也就是当类比较简单的时候还可以, ...
  • Java BeanUtils对象复制工具类及方法

    千次阅读 2018-12-14 17:02:37
    1. BeanUtils.copyProperties(Object source, Object target...用法: 讲source的属性值复制到target,属性为null时也会进行复制。 需求:排除null值进行复制 public class CopyObjectUtil { public static String...
  • 就比如 A a=new A(); 将a复制给b 但他们两个是不同的两个对象,a==b//false 有什么方法吗,不用clone
  • Java Bean对象复制的三种方式详解

    千次阅读 2020-04-25 22:58:18
    一般Java对象复制包含**浅拷贝、深度复制、BeanUtils.copyProperties()**等三种方式。 对象的克隆是指创建一个新的对象,且新的对象的状态与原始对象的状态相同且我们对新对象修改时,不影响原对象的状态。 原理...
  • JAVA对象属性复制

    万次阅读 2012-08-10 13:33:26
    编程过程中,有些时候某些不同的类有相同的字段,可能会遇到同时给他们赋值的情况... 简单的时候,可以写重复的代码......复制对象必须同时拥有setter和getter方法...只有一个的时候会报异常,都没有的时候就不复制..
  • Java集合对象的深度复制与普通复制

    万次阅读 2015-10-30 21:27:21
    最近在开发中遇到了一些关于集合复制的一些问题...所以当拷贝的集合修改了集合对象内的数据,那么源集合对象也就随之改变了,这样的效果我们称之为Java集合对象的浅复制,即只是在栈中拷贝了,而堆中的数据并没有拷贝。
  • java bean对象之间复制属性

    千次阅读 2015-07-25 18:07:46
    java bean对象之间复制属性
  • java不同对象之间同名属性值复制

    千次阅读 2017-09-18 12:50:21
    方法能够将源对象和目标对象中相同名称的属性值复制过去。注意的是参数前面的是目标对象,后面是源对象。使用该方法需要注意:不能将入口方法与源对象、目标对象之一放在同一源文件之内,否者将没有任何效果。 使用...
  • java对象clone()方法

    万次阅读 多人点赞 2018-05-10 18:37:47
    java赋值是复制对象引用,如果我们想要得到一个对象的副本,使用赋值操作是无法达到目的的: @Test public void testassign(){ Person p1=new Person(); p1.setAge(31); p1.setName("Peter"); Person p2=p1; ...
  • JAVA 面向对象方法详解

    千次阅读 2016-07-17 23:08:29
    方法是类或对象 的行为特征的抽象. 方法是类或对象最重要的组成部分. 所有的方法都必需定义在类里. 方法不能独立存在. 方法在逻辑上要么属于类, 要么属于对象. 方法的所属性 一旦将一个方法定义在某个类的...
  • Java对象复制

    千次阅读 2018-11-09 09:42:33
    原文地址 ... 工具类BeanUtils和PropertyUtils进行对象复制 Student stu1 = new Student(); stu1.setNumber(12345); Student stu2 = new Student(); BeanUtils.copyPro...
  • 细说java对象的浅复制和深复制

    千次阅读 2016-10-22 13:53:23
    复制和深复制的区别 ...实现浅复制和深复制,主要是使用cloneable接口的clone方法,还是比较简单的,不多说了,直接上代码。 浅复制(shallow clone) public class Husband implements Cloneable { private int
  • Java对象复制、浅复制

    千次阅读 2016-04-27 18:11:35
    我们在编码过程经常会碰到将一个对象传递给另一个对象,java中对于基本型变量采用的是值传递,而对于对象比如bean传递时采用的引用传递也就是...浅复制(浅克隆) :被复制对象的所有变量都含有与原来的对象相同的值,
  • http://blog.csdn.net/zhangjg_blog/article/details/18369201 http://www.cnblogs.com/o-andy-o/archive/2012/04/06/2434904.html
  • java如何复制完整对象

    千次阅读 2018-08-30 10:28:13
    BeanUtils.cloneBean和BeanUtils.copyProperties复制对象不完全一样。 解决方法: 要被复制的类实现Cloneable接口,http://www.yayihouse.com/yayishuwu/chapter/1553
  • java对象复制和属性值复制工具类

    千次阅读 2017-11-30 16:19:10
    两个不同类型的对象中有字段名称不区分大小写的情况下一样,字段含义一样,需要组装到另一个对象中去,然后就写了一个这种工具类 我的类型比较特殊,老系统和新系统的对象命名大小写命名不一致,并且字段相同类型也...
  • java 对象中集合属性及复制

    千次阅读 2018-12-21 12:53:16
    java 对象中集合属性及复制 本文我们介绍集合属性的复制场景及多种实现方式。 对象中集合属性 实际应用中对象中的集合属性很常见,表达一对多的关系。如用户有多个地址,订单包括多个产品等。一般我们需要定义集合...
  • Java之Map对象复制小例子

    千次阅读 2016-05-19 22:34:03
    开心一笑提出问题Map对象的简单复制问题????解决问题例一:map对象引用复制,只是简单的引用,解决不了问题package com.evada.de;import java.util.HashMap; import java.util.Map;/** * Created by Ay on 2016...
  • Java List 深度复制方法

    万次阅读 2017-07-28 16:20:06
    前言之前探讨过Java数组的深复制问题,现在来说说<一些不靠谱的java.util.List深复制方法>。为什么不说<靠谱的深复制方法>呢?因为在寻找探索<靠谱的深复制方法>的过程中,我发现了这些不靠谱的方法,写下来是希望给...
  • Java对象复制非空属性

    千次阅读 2019-02-25 15:06:15
    引用org.springframework.beans.BeanUtils类提供的方法copyProperties(Object ... ignoreProperties) 用于对象拷贝,spring 和 Apache都提供了相应的工具类方法,BeanUtils.copyProperties package com.mixislink...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 425,042
精华内容 170,016
关键字:

java复制对象的方法

java 订阅