精华内容
下载资源
问答
  • java的两种深度克隆方法,1cloneTest是用Cloneable接口的clone方法实现(对象必须要实现cloneable接口).2cloneSerialize.java是用对象流写对象到byte数组中,然后从byte数组中取得对象.(对象必须要实现serializble接口)
  • 本篇文章是对JAVA对象深度克隆进行了详细的分析介绍,需要的朋友参考下
  • 正经学徒,佛系记录,不搞事情第一步:创建工具类直接使用commons-beanutils实现对象拷贝,引入pomcommons-beanutilscommons-beanutils1.9.3创建工具类:BeanUtilspublic class BeanUtils {/*** @param orig 源对象*...

    正经学徒,佛系记录,不搞事情

    第一步:创建工具类

    直接使用commons-beanutils实现对象拷贝,引入pom

    commons-beanutils

    commons-beanutils

    1.9.3

    创建工具类:BeanUtils

    public class BeanUtils {

    /**

    * @param orig 源对象

    * @param dest 目标对象

    */

    public static void copyProperties(final Object orig,final Object dest){

    try{

    org.apache.commons.beanutils.BeanUtils.copyProperties(dest, orig);

    }catch (Exception e){

    throw new RuntimeException(e.getMessage());

    }

    }

    /**

    * @Description:拷贝list元素对象,将origs中的元素信息,拷贝覆盖至dests中

    * @param origs 源list对象

    * @param dests 目标list对象

    * @param origsElementTpe 源list元素类型对象

    * @param destElementTpe 目标list元素类型对象

    * @param 源list元素类型

    * @param 目标list元素类型

    */

    public static void copyProperties(final Listorigs, final Listdests, ClassorigsElementTpe, ClassdestElementTpe){

    if(origs==null||dests==null){

    return ;

    }

    if(dests.size()!=0){

    //防止目标对象被覆盖,要求必须长度为零

    throw new RuntimeException("目标对象存在值");

    }

    try{

    for (T1 orig: origs) {

    T2 t = destElementTpe.newInstance();

    dests.add(t);

    copyProperties(orig,t);

    }

    }catch (Exception e){

    throw new RuntimeException(e.getMessage());

    }

    }

    }

    注:抛出异常部分可根据实际项目需要,抛出自定义异常。

    第二步:测试

    创建两个实体类,实体类只相差一个属性,用于测试

    BeanOne.java

    private String id;

    private String name;

    private String beanOne;

    BeanTwo.java

    private String id;

    private String name;

    private String beanTwo;

    测试直接拷贝对象:

    BeanOne orig = new BeanOne("123","张三","one");

    //直接赋值

    BeanOne dest = orig;

    //修改值

    dest.setId("456");

    dest.setName("李四");

    System.out.println("赋值后的原始值:"+orig.toString());

    System.out.println("赋值后新对象值:"+dest.toString());

    1545eeed0fa004ce811e5221d7f538ea.png

    结果:直接拷贝对象时,是地址拷贝,orig与dest指向同一个地址,导致修改dest会影响到orig

    测试深度克隆拷贝相同类型对象:

    BeanOne orig = new BeanOne("123","张三","one");

    //深度克隆

    BeanOne dest = new BeanOne();

    BeanUtils.copyProperties(orig,dest);

    dest.setId("456");

    dest.setName("李四");

    System.out.println("赋值后的原始值:"+orig.toString());

    System.out.println("赋值后新对象值:"+dest.toString());

    85e628651fd1d5e02c335c271e8317af.png

    结果:修改dest不会影响到orig的值

    测试深度克隆拷贝不相同类型对象:

    BeanOne orig = new BeanOne("123","张三","one");

    //深度克隆

    BeanTwo dest = new BeanTwo();

    BeanUtils.copyProperties(orig,dest);

    dest.setName("李四");

    System.out.println("赋值后的原始值:"+orig.toString());

    System.out.println("赋值后新对象值:"+dest.toString());

    2ef1365587a29a19f16116a5f1821972.png

    结果:不同类型的对象之间的拷贝,则相同属性会拷贝,不同属性不会拷贝

    注:追溯org.apache.commons.beanutils.BeanUtils源码,克制对象之间的拷贝是通过属性名的而与类型无关,未避免异常,两个不同类型的对象之间的拷贝,尽可能保证相同属性名的类型也保持一致。

    测试深度克隆拷贝集合对象:

    Listorigs = new ArrayList<>();

    origs.add(new BeanOne("123","张三","one"));

    origs.add(new BeanOne("456","李四","one1"));

    //深度克隆

    Listdests = new ArrayList<>();

    BeanUtils.copyProperties(origs,dests,BeanOne.class,BeanTwo.class);

    for(BeanTwo temp : dests){

    temp.setName("都是two");

    }

    System.out.println("赋值后的原始值:"+origs.toString());

    System.out.println("赋值后新对象值:"+dests.toString());

    1bfead71a45269428c0a570e275effe2.png

    结果:拷贝成功,且不影响原始值

    展开全文
  • Java实现对象深度克隆

    2021-03-07 15:44:56
    实现Serializable接口,通过对象的序列化和反序列化实现克隆,可以实现真正的深度克隆,代码如下 import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io....

    两种方式:
      1). 实现Cloneable接口并重写Object类中的clone()方法;
      2). 实现Serializable接口,通过对象的序列化和反序列化实现克隆,可以实现真正的深度克隆,代码如下

    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class MyUtil {
    
        private MyUtil() {
            throw new AssertionError();
        }
    
        @SuppressWarnings("unchecked")
        public static <T extends Serializable> T clone(T obj) throws Exception {
            ByteArrayOutputStream bout = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bout);
            oos.writeObject(obj);
    
            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bin);
            return (T) ois.readObject();
    
            // 说明:调用ByteArrayInputStream或ByteArrayOutputStream对象的close方法没有任何意义
            // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源,这一点不同于对外部资源(如文件流)的释放
        }
    }
    class Student implements Cloneable{
        private String name;
        private int age;
        private StudentClass studentClass;
        private List<String> list = new ArrayList<>();
        
        public Student() {
            // TODO Auto-generated constructor stub
            System.out.println("构造方法被调用");
        }
        
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public StudentClass getStudentClass() {
            return studentClass;
        }
     
     
        public void setStudentClass(StudentClass studentClass) {
            this.studentClass = studentClass;
        }
        
        public void add(String aa){
            this.list.add(aa);
        }
     
     
        @Override
        public Object clone() throws CloneNotSupportedException {
            // TODO Auto-generated method stub
            Student stu = (Student) super.clone();
            
            return stu;
        }
        @Override
        public String toString() {
            return "Student [name=" + name + ", age=" + age + ",class"+studentClass.getStudentClass()+",list"+list+"]";
        }
        
    }

     

    展开全文
  • 克隆对象的Class实现Cloneable接口2. 克隆对象的Class实现Serializable接口 关于克隆(Object[clone]) 克隆,主要作用是将当前对象进行复制拷贝,保留原有对象持有的属性、状态。是来自Object类中的clone方法,被...

    关于克隆(Object[clone])

    克隆,主要作用是将当前对象进行复制拷贝,保留原有对象持有的属性、状态。是来自Object类中的clone方法,被关键字native修饰,是非java语言实现的接口。首先看一下Object中的clone方法,如下:
    在这里插入图片描述

    为什么使用克隆?克隆的场景是什么?

    当程序运行中时,需要A对象的相同属性、状态来生成新的对象B,B对象与A对象具有相同的属性、状态。而A对象会继续执行后续的业务,同时后续的业务中也使用B对象。

    克隆的分类

    Java中的克隆,主要分为两类:

    1. 浅度克隆:只克隆对象的基本数据类型的属性,不会克隆引用类型的属性。当然,基本数据类型的包装类和String类型除外
    2. 深度克隆:克隆当前对象的所有持有属性(所有数据类型)。

    克隆方式

    1. 克隆对象的Class实现Cloneable接口

    public class Student implements Cloneable {}
    

    实现Cloneable接口后,方可使用Object中的clone方法。但是此方式只能克隆对象的基本数据类型(包括基本数据类型的包装类)和String类型的属性,属于浅度克隆。
    如果要想通过此方式实现深度克隆,必须给克隆对象持有的引用类型的Class也实现Cloneable接口。代码如下:

    Student类:

    public class Student implements Cloneable {
    	private int	stuId; // 学号
    	private Teacher teacher; //持有Teacher对象
    	// 克隆
    	@Override
    	public Object clone() throws CloneNotSupportedException {
    		// 调用Object的clone方法,并强制转换为Student,得到新的Student对象stuClone
    		Student stuClone = (Student)super.clone();
    		// 从stuClone中获取teacher,这里的teacher并没有真正的实现克隆,只是持有引用。
    		// 实际上,stuClone里的teacher引用指向的是原Student对象中teacher的内存堆地址。
    		// 目前,原student对象与新的stuClone对象两者引用的Teacher是同一个Teacher对象。
    		Teacher teacher = (Teacher)stuClone.getTeacher()
    		// 现在,将从stuClone拿到的teacher对象再进行克隆,并将克隆到的teacherClone对象给stuClone
    		Teacher teacherClone = teacher.clone();
    		stuClone.setTeacher(teacherClone);
    	}
    	
    	public Teacher getTeacher() {
    		return teacher;
    	}
    	
    	public void setTeacher(Teacher teacher) {
    		this.teacher = teacher;
    	}
    }
    

    Teacher类:

    
    public class Teacher implements Cloneable {
    	// 学科
    	private String subject;
    	// 克隆
    	@Override
    	public Object clone() throws CloneNotSupportedException {
    		// 调用Object的clone方法
    		Object obj = super.clone();
    		return obj;
    	}
    	public String getSubject() {
    		return subject;
    	}
    	
    	public void setSubject(String subject) {
    		this.subject = subject;
    	}
    }
    

    小结: 实现Cloneable接口的方式,做浅度克隆还可以,但是要做深度克隆的话,需要手动地将对象的引用类型(基本数据类型的包装类和String类型除外)一个一个的克隆,维护起来很麻烦。本人不推荐使用。

    2. 克隆对象的Class实现Serializable接口

    public class Student implements Serializable {}
    

    实现Serializable接口,利用序列化的方式实现克隆,这种方式是深度克隆。

    其中原理:利用IO流方式,将对象写入流里,再从流里将对象读取出来(这一过程其实相当于复制拷贝)。实现Serializable的会将引用类型一并进行克隆。

    为了方便,我这里使用了继承。父类:Person 子类:Student、Teacher。直接上代码:

    Person类:

    // 父类实现序列化接口Serializable,子类只需继承便可
    public class Person implements Serializable {
    	
    	/** serialVersionUID */
    	private static final long	serialVersionUID	= 1L;
    	// 年龄
    	private int					age;
    	// 姓名
    	private String				name;
    	
    	public Person() {}
    	
    	public Person(int age, String name) {
    		this.age = age;
    		this.name = name;
    	}
    	// 此方法是普通克隆方法
    	public Person clone() {
    		try {
    			// 创建输出流,将对象放入流里
    			ByteArrayOutputStream baos = new ByteArrayOutputStream();
    			ObjectOutputStream oos = new ObjectOutputStream(baos);
    			oos.writeObject(this);
    			// 创建输入流,将对象读出来
    			ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    			ObjectInputStream ois = new ObjectInputStream(bais);
    			Person obj = (Person) ois.readObject();
    			return obj;
    		} catch (Exception e) {
    			e.printStackTrace();
    			return null;
    		}
    	}
    	// 此方法是利用泛型的克隆方法,省去了最后的强制转换过程
    	// 同时也限制了被克隆类的类型,必须继承Person
    	public <T> T clone(Class<T> clazz) {
    		try {
    			// 如果目标类没有继承关系,可以将下面判断条件删除
    			T newInstance = clazz.newInstance();
    			if (!(newInstance instanceof Person)) {
    				// 如果不是Person类型,抛异常
    				throw new Exception("被clone的对象不属于基类Person类型");
    			}
    			// 创建输出流,将对象放入流里
    			ByteArrayOutputStream baos = new ByteArrayOutputStream();
    			ObjectOutputStream oos = new ObjectOutputStream(baos);
    			oos.writeObject(this);
    			// 创建输入流,将对象读出来
    			ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    			ObjectInputStream ois = new ObjectInputStream(bais);
    			Object readObject = ois.readObject();
    			// 将对象转换为规定的泛型
    			T obj = clazz.cast(readObject);
    			return obj;
    		} catch (Exception e) {
    			e.printStackTrace();
    			return null;
    		}
    	}
    	
    	public int getAge() {
    		return age;
    	}
    	
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    	public String getName() {
    		return name;
    	}
    	
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    }
    

    Student类:

    // 继承父类Person
    public class Student extends Person {
    	
    	/** serialVersionUID */
    	private static final long	serialVersionUID	= 1L;
    	// 学号
    	private int					stuId;
    	// 持有应用类型Teacher对象
    	private Teacher				teacher;
    	
    	public Student() {}
    	
    	public Student(int age, String name, int stuId) {
    		super(age, name);
    		this.stuId = stuId;
    	}
    	
    	public int getStuId() {
    		return stuId;
    	}
    	
    	public void setStuId(int stuId) {
    		this.stuId = stuId;
    	}
    	
    	public Teacher getTeacher() {
    		return teacher;
    	}
    	
    	public void setTeacher(Teacher teacher) {
    		this.teacher = teacher;
    	}
    	
    	@Override
    	public String toString() {
    		return "Student [age=" + this.getAge()+ ",name=" + this.getName()+ ",stuId=" + stuId + ", teacher=" + teacher + "]";
    	}
    	
    }
    

    Teacher类:

    public class Teacher extends Person {
    	
    	/** serialVersionUID */
    	private static final long	serialVersionUID	= 1L;
    	// 学科
    	private String				subject;
    	
    	public Teacher() {
    	}
    	
    	public Teacher(String subject) {
    		this.subject = subject;
    	}
    	
    	public String getSubject() {
    		return subject;
    	}
    	
    	public void setSubject(String subject) {
    		this.subject = subject;
    	}
    	
    	@Override
    	public String toString() {
    		return "Teacher [subject=" + subject + "]";
    	}
    	
    }
    

    测试:

    public static void main(String[] args) {
    		// 创建学生对象
    		Student stu1 = new Student(10, "zhangsan", 1001);
    		// 给学生安排一个体育老师
    		stu1.setTeacher(new Teacher("体育"));
    		System.out.println("学生:" + stu1.toString());
    		// 克隆
    		Student clone = stu1.clone(Student.class);
    		System.out.println("克隆" + clone.toString());
    		System.out.println("------------------修改后--------------------");
    		// 修改克隆对象的属性
    		clone.setAge(22);
    		clone.setName("lisi");
    		clone.setStuId(1002);
    		clone.getTeacher().setSubject("语文");
    		System.out.println("克隆对象:" + clone.toString());
    		System.out.println("学生对象:" + stu1.toString());
    	}
    

    打印输出:

    学生:Student [age=10,name=zhangsan,stuId=1001, teacher=Teacher [subject=体育]]
    克隆:Student [age=10,name=zhangsan,stuId=1001, teacher=Teacher [subject=体育]]
    ------------------修改后--------------------
    克隆对象:Student [age=22,name=lisi,stuId=1002, teacher=Teacher [subject=语文]]
    学生对象:Student [age=10,name=zhangsan,stuId=1001, teacher=Teacher [subject=体育]]

    可以看出,克隆之后修改了克隆对象的基本类型和引用类型的属性,被克隆对象的属性并没有做任何修改。这就是深度克隆。

    总结:两种方式实现了对象的克隆,针对深度克隆而言,实现Serializable这种方式要比实现Cloneable方式简单方便的多,而且易维护。
    推荐使用Serializable!

    原创文章,有不足之处还请各路大神多多指点,多多包涵。
    如需转载,请标明出处,不胜感激。
                                                                                                            —— 码上仙

    展开全文
  • 本篇文章是对序列化存取实现java对象深度克隆方法进行了详细的分析介绍,需要的朋友参考下
  • java中实现对象深度克隆

    千次阅读 2018-08-03 10:08:25
    python中有深度拷贝(也可以叫深度克隆)和浅拷贝,同样在java中很多时候需要深度拷贝对象,所谓的深度拷贝对象指的就是对于对象的所用数据及其全部进行copy一份,变成两个完全不相关的对象,而浅拷贝不拷贝对象...

    1.什么是深度拷贝和浅拷贝       

           python中有深度拷贝(也可以叫深度克隆)和浅拷贝,同样在java中很多时候需要深度拷贝对象,所谓的深度拷贝对象指的就是对于对象的所用数据及其全部进行copy一份,变成两个完全不相关的对象,而浅拷贝不拷贝对象所用的数据资源等,虽是两个不同的参数标识符,但是用的是同一个数据对象,也就是用‘==’,这是浅拷贝。也就是C语言中形容的指针指向的物理存储区域对象其实是一个。

          带来的问题:浅拷贝无论你通过任何浅拷贝的对象修改其值,最后的其他的对象都会被改变,相信我,这是一个很常见的坑。

    2.java对象的深度拷贝

            其实java中的很多对象已经实现了深度拷贝,比如说map中的putAll(),但是需要实现自己创建的对象的深度拷贝呢,山不转水转,总会碰到的。

           下面来说明一下java中的深度拷贝,其最佳的方式就是实现Serializable接口,用序列化和反序列化来实现对象的深度拷贝,所谓的序列化和反序列化简单说明下,序列化指的就是把对象直接转化成文件或者其他持久层数据(二进制文件,字节码文件),反序列化指的就是读出该数据,重新建立对象的过程。因为java中的JVM虚拟机是有生命周期的,所以说任何对象的生命周期不会超过当前的JVM虚拟机的生命周期,所以需要序列化和反序列化,解决办法就是给其Serializable中有一个ID值,是不是原来一看到别人写的Serializable就不知道东南西北了,这个表示的就是版本号,防止错乱嘛。下面来介绍一下java对象的深度克隆。

    3.java中的实现及其原理分析

           java中的对象的深度克隆主要的原理就是实现对象的字节流转换,然后在把当前的字节流对象输出,得到新的对象。代码:

    public Object deepClone() {
                try {
                    ByteArrayOutputStream bos = new ByteArrayOutputStream();//字节流对象
                    ObjectOutputStream oos = new ObjectOutputStream(bos);//开始转换该对象
                    oos.writeObject(this);//写到当前类,当然也可以写入文件
                    ByteArrayInputStream bais = new ByteArrayInputStream(bos.toByteArray());//字节输出流
                    ObjectInputStream ois = new ObjectInputStream(bais);//输出该对象
                    return (Object) ois.readObject();//读出对象,实现新对象的生成
                } catch (Exception e) {
                    System.out.println("克隆出错"+e.getStackTrace());
                    return null;
                }
            }
        }

    4.测试结果代码

    原理实际上非常的简单,下面来测试一下,完整的代码:

    package java_test;

    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;


    public class study implements Serializable{
        private static final long serialVersionUID = 1L;
        public static  int arr[] = {1,2};
        
        public static class class1 {//内部类,也是我们克隆的对象

            public Object deepClone() {
                try {
                    ByteArrayOutputStream bos = new ByteArrayOutputStream();
                    ObjectOutputStream oos = new ObjectOutputStream(bos);
                    oos.writeObject(this);
                    ByteArrayInputStream bais = new ByteArrayInputStream(bos.toByteArray());
                    ObjectInputStream ois = new ObjectInputStream(bais);
                    return (Object) ois.readObject();
                } catch (Exception e) {
                    System.out.println("克隆出错"+e.getStackTrace());
                    return null;
                }
            }
        }
        
        public static void main(String[] args) {//验证一下克隆前和克隆后是不是一个对象
            class1 c = new class1();
            Object c2 = c;
            if (c == c2){
                System.out.println("克隆前c和出c2相等,也就是c和c2其实是一个对象!");
            }else{
                System.out.println("克隆前c和出c2不相等,出现理论不符合逻辑错误!");
            }
            c2 = c.deepClone();
            
            if (c == c2){
                System.out.println("深度克隆失败");
            }else{
                System.out.println("深度克隆成功");
            }
        }
    }

    结果:

    测试程序,本文观点来自个人理解,有不足之处请之处,希望不吝赐教。

    展开全文
  • 前言这也是昨天的面试题。当时只说了深拷贝以及浅拷贝,面试官问了两遍还有吗,我很肯定的说就这两种了,面试结束之后查了...深度克隆应该递归克隆引用类型的成员属性。浅克隆实现实现Cloneable接口重写clone方法...
  • 主要介绍了Java编程实现对象克隆(复制)代码详解,涉及了克隆的原因,如何实现克隆克隆的一般步骤,深克隆与浅克隆的介绍等相关内容,具有一定借鉴价值,需要的朋友可以参考下。
  • Java深度克隆对象

    2019-03-07 14:07:03
    Java序列化深度克隆对象,被克隆的对象要求实现序列化 //深度克隆 public static Object deepCopy(Serializable source) { ObjectOutputStream os = null; ObjectInputStream ois = null; Object target = ...
  • 首先导入依赖 <!--fastjson--> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.75</version>...pub
  • 如何深度克隆一个对象在我们日常工作中经常会遇到需要去克隆一个对象比如多个地方用到的公共的图表基本参数的配置相信很多人会想到用 Object.assign, JSON.stringify 和 JSON.parse 方法去克隆一个对象,这个可以...
  • java深度克隆工具类

    2021-02-12 19:30:32
    第一步:创建工具类直接使用commons-beanutils实现对象拷贝,引入pomcommons-beanutilscommons-beanutils1.9.3创建工具类:BeanUtilspublic class BeanUtils {/*** @param orig 源对象* @param dest 目标对象*/...
  • java深度克隆

    2012-05-29 09:10:19
    java深度克隆,可以复制对象,非常好用,谁用谁知道!
  • java深度克隆

    2021-03-01 09:25:40
    http://hi.baidu.com/koflance/blog/item/07809915d6f70e5cf3de32dd.html http://www.iteye.com/topic/1113790 java对象克隆步骤: 1.类需要实现Cloneable接口 2 覆盖clone方法,调用super.clone即可。如果是复合...
  • 如果不用对象的copy也可以做,只不过需要我手动把每个字段一个一个转移,工作量大,还不利用后期维护,就想到用对象深度克隆解决,先留个坑,解决后,在写解决的方法。 草图帮助理解: 可以用org.spring...
  • Java对象克隆

    2021-02-28 12:46:46
    Java对象克隆1 什么是Java对象克隆对象克隆是创建一个对象的副本的方式。Object类的clone() 方法用于克隆对象java.lang.Cloneable接口必须由我们要建立其对象克隆的类实现。如果我们不实现Cloneable接口,则clone...
  • java反射机制创建对象实现:java 深度拷贝 -超完美,只使反射机制,不使用其它封装好的深度拷贝的工具类
  • # clone的条件如果你想clone一个对象,就必须满足两个条件:1. 你必须实现Cloneable接口(用于标识该对象可被clone,空接口)2. 必须覆盖Object的clone方法clone分为浅克隆和深克隆。... 先使用待克隆对象的clone方...
  • java 对象深度复制Today we will look into Java deep copy. Sometimes we want to get a copy of an Object, but java works on reference and if we don’t want to alter the original object then we need to ...
  • java对象深度克隆

    2020-07-23 11:49:16
    //将e对象中的属性克隆到dto中 BeanUtils.copyProperties(e, dto);
  • java对象克隆

    2021-03-05 15:41:36
    两种不同的克隆方法,浅克隆(ShallowClone)和深克隆(DeepClone)。在Java语言中,数据类型分为值类型(基本数据类型)和引用类型,byte、short、int、long、flout、double、boolean、char8种简单数据类型,引用类型包括...
  • 如果需要克隆对象,一般需要先创建一个对象,然后将原对象中的数据导入到新创建的对象中去,而不用根据已有对象进行手动赋值操作。二:Object中的clone()方法protected native Object clone() throws ...
  • FastJson中的JSONObject的常用方法总结,JSONObject与java对象的转换,java对象与JSONObject的转换,利用JSONObject来深度克隆对象 maven项目中的依赖包: <dependency> <groupId>com.alibaba</...
  • Java对象深度克隆

    千次阅读 2019-03-25 16:00:41
    日常写代码过程中我们需要对数据和对象等进行克隆,然而对引用类型必须要自己重写clone()方法,对于复杂的对象并不那么好写,而且每个对象都需要重写一次。这里我不重写clone()方法,而是使用输入输出流进行克隆。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,571
精华内容 3,828
关键字:

java深度克隆对象方法

java 订阅