精华内容
下载资源
问答
  • Java实现深克隆

    2018-03-13 08:52:02
     引用至:... import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.ObjectInputStream;...

     引用至:http://blog.csdn.net/kenthong/article/details/5758884

    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    public abstract class BeanUtil {
    	@SuppressWarnings("unchecked")
    	public static  T cloneTo(T src) throws RuntimeException {
    		ByteArrayOutputStream memoryBuffer = new ByteArrayOutputStream();
    		ObjectOutputStream out = null;
    		ObjectInputStream in = null;
    		T dist = null;
    		try {
    			out = new ObjectOutputStream(memoryBuffer);
    			out.writeObject(src);
    			out.flush();
    			in = new ObjectInputStream(new ByteArrayInputStream(memoryBuffer.toByteArray()));
    			dist = (T) in.readObject();
    		} catch (Exception e) {
    			throw new RuntimeException(e);
    		} finally {
    			if (out != null)
    				try {
    					out.close();
    					out = null;
    				} catch (IOException e) {
    					throw new RuntimeException(e);
    				}
    			if (in != null)
    				try {
    					in.close();
    					in = null;
    				} catch (IOException e) {
    					throw new RuntimeException(e);
    				}
    		}
    		return dist;
    	}
    }

     

    展开全文
  • 在说Cloneable接口前,先将一下什么是浅克隆,什么是深克隆 浅克隆 浅克隆,顾名思义就是把表层的东西复制一份,对于基础数据类型来说,就是把值克隆一份(栈中的值),而对引用数据类型而言,则是复制了一份引用...

    什么是浅克隆,什么是深克隆

    1. 浅克隆
      浅克隆,顾名思义就是把表层的东西复制一份,对于基础数据类型来说,就是把值克隆一份(栈中的值),而对引用数据类型而言,则是复制了一份引用地址。例如
    User user1 = new User();
    User user2 = user1;
    

    以上代码可以理解为浅克隆,两个对象操作的都是同一个引用地址

    1. 深克隆
      沈克隆,则比浅克隆要克隆的更加深层次,深克隆相当于是直接又创建了一个属性相同的对象,可以理解为在堆中,把原有空间的值,复制了一份,放到另一个空间,两个对象的引用地址是不相等的
    2. Cloneable接口(Java的浅克隆实现)
      创建一个实体类,实现Cloneable接口
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class Person  implements Cloneable{
    
        private String name;
        private String sex;
    
        @Override
        public Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
        
    }
    
    

    实现接口中clone方法,并将方法访问级别修改为public,这样外部才能够调用,方法中不需要有别的实现,直接调用父级的clone()方法即可,具体的实现交给JVM。
    Cloneable接口类似于Serializable接口,只是做一个标记的作用。
    这样就实现了Java的浅克隆,编写Main方法测试一下。

        public static void main(String[] args) throws CloneNotSupportedException {
            Person person = new Person("张三","男");
            System.out.println("源对象值:"+person);
            Person clone = (Person) person.clone();
            System.out.println("克隆对象值:"+clone );
        }
    

    在这里插入图片描述
    可以看到,两个对象的所有属性值都是一样的,那么来打印一下两个对象的引用地址

            System.out.println("源对象内存地址:"+System.identityHashCode(person));
            System.out.println("克隆对象内存地址:"+System.identityHashCode(clone));
    

    在这里插入图片描述
    可以看到两个内存地址是不相等的,那么这里就有一个问题,为什么浅克隆之后,两个对象的引用地址是不一样的呢,这里就要看看clone()方法的一个实现过程了。
    在源对象在调用了clone方法之后,会先分配一个内存给新的对象,这个内存地址与源对象的相同,然后将源对象中各个属性的值,通过浅克隆拷贝到新对象中,填充完成后,返回一个新的内存地址,再赋值给新的内存对象,所以就导致了源对象和克隆之后的新对象内存地址不相同的情况。
    想要验证clone是不是浅拷贝其实很简单,在Person.java实体类中添加一个引用类型的属性
    1、新建实体类

    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Clothes {
    
        private String color;
    
    }
    
    

    2、在Person.java实体中新增一个属性,类型为Clothes .java

    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class Person  implements Cloneable{
    
        private String name;
        private String sex;
        private Clothes clothes;
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    
    }
    

    3、结果

        public static void main(String[] args) throws CloneNotSupportedException {
            Person person = new Person("张三","男",new Clothes("红色"));
            System.out.println("源对象值:"+person);
            Person clone = (Person) person.clone();
            System.out.println("克隆对象值:"+clone );
    
            System.out.println("源对象内存地址:"+System.identityHashCode(person));
            System.out.println("克隆对象内存地址:"+System.identityHashCode(clone));
    
            System.out.println("源对象中clothes属性的内存地址:"+System.identityHashCode(person.getClothes()));
            System.out.println("克隆对象中clothes属性的内存地址:"+System.identityHashCode(clone.getClothes()));
        }
    

    在这里插入图片描述
    可以看到,clothes属性的引用地址是没有变化的,如果person对象或clone对象更改了clothes的属性,都会影响到另一个对象

    1. 通过Cloneable接口实现深克隆
      想要对Clothes.java类通过Cloneable实现深克隆其实也不难,只需要重复一个对Person.java的操作即可
      为Clothes.java类实现Cloneable接口
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Clothes implements Cloneable {
    
        private String color;
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    

    然后更改Person.java类的clone()方法实现

    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class Person  implements Cloneable{
    
        private String name;
        private String sex;
        private Clothes clothes;
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            Person person = (Person)super.clone();
            Clothes clothes = (Clothes) person.getClothes().clone();
            person.setClothes(clothes);
            return person;
        }
    
    }
    
    

    最后再来看看结果

        public static void main(String[] args) throws CloneNotSupportedException {
            Person person = new Person("张三","男",new Clothes("红色"));
            System.out.println("源对象值:"+person);
            Person clone = (Person) person.clone();
            System.out.println("克隆对象值:"+clone );
    
            System.out.println("源对象内存地址:"+System.identityHashCode(person));
            System.out.println("克隆对象内存地址:"+System.identityHashCode(clone));
    
            System.out.println("源对象中clothes属性的内存地址:"+System.identityHashCode(person.getClothes()));
            System.out.println("克隆对象中clothes属性的内存地址:"+System.identityHashCode(clone.getClothes()));
        }
    

    在这里插入图片描述
    可以看到clothes属性的内存地址已经变了。
    但是这种实现方式,太过于麻烦,每次加一个属性,就要递归一次,而且还需要保证每个类都需要实现Cloneable接口。为了解决这个问题,来看看第二种实现深克隆的方法。

    1. 通过Serializable接口实现深克隆
      Clothes.java类代码
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import java.io.Serializable;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Clothes implements Serializable {
    
        private static final long serialVersionUID = 4267357190457512479L;
        private String color;
    }
    
    

    Person.java类代码

    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import java.io.*;
    
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class Person implements Serializable {
    
        private static final long serialVersionUID = -3660354394033292895L;
    
        private String name;
        private String sex;
        private Clothes clothes;
    
        public Person clone(){
            Person person = null;
            try {
                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream);
                outputStream.writeObject(this);
    
                ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
                ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
                person = (Person)objectInputStream.readObject();
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
            return person;
        }
    
    }
    

    结果

        public static void main(String[] args) {
            Person person = new Person("张三","男",new Clothes("红色"));
            System.out.println("源对象值:"+person);
            Person clone = person.clone();
            System.out.println("克隆对象值:"+clone );
    
            System.out.println("源对象内存地址:"+System.identityHashCode(person));
            System.out.println("克隆对象内存地址:"+System.identityHashCode(clone));
    
            System.out.println("源对象中clothes属性的内存地址:"+System.identityHashCode(person.getClothes()));
            System.out.println("克隆对象中clothes属性的内存地址:"+System.identityHashCode(clone.getClothes()));
        }
    

    在这里插入图片描述
    为什么序列化会改变对象的内存的,因为Java的序列化,是将对象,转换为流一个的过程。序列化不仅仅是保存一个对象的数据,是会通过递归将对象中所有层次的对象的数据全部保留,也就是全部取出,转换为了流。这个流保存成文件,也可以在网络之间传输,如果保存的是内存地址,那么就不能在网络之间传输也不能保存成文件。
    所以也不难理解为什么序列化之后会改变对象的内存地址。对象的所有数据都被复制了一份,取出,转换为流,在读取出来之后,又转换为对象,在堆中重新开辟地址,分配新的内存地址,成为了一个新的对象。

    展开全文
  • Java实现深克隆的三种方式

    千次阅读 2019-11-15 17:14:13
    大家都知道,Java中的克隆有深克隆和浅克隆,今天我们谈谈深克隆的几种实现方式。 首先,我们先谈谈浅克隆的实现 一、浅克隆 Java实现浅克隆主要就是要实现Cloneable接口,然后返回克隆对象。 假设,现在我们...

    大家都知道,Java中的克隆有深克隆和浅克隆,今天我们谈谈深克隆的几种实现方式。

    首先,我们先谈谈浅克隆的实现

    一、浅克隆

    Java中实现浅克隆主要就是要实现Cloneable接口,然后返回克隆对象。

    假设,现在我们有两个类,账户类Account和账户详情类AccountDetail,代码如下:

    /**
     * 类名 Account
     * 描述 账户类
     */
    @Data
    @EqualsAndHashCode(callSuper = false)
    @ToString
    @NoArgsConstructor
    @AllArgsConstructor
    public class Account implements Cloneable{
        /** 主键 */
        private Long id;
        /** 账户名称 */
        private String name;
        /** 账户详情 */
        private AccountDetail detail;
        /** 重写clone方法,改为public方便外部调用 */
        @Override
        public Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    
    
    /**
     * 类名 AccountDetail
     * 描述 账户详情类
     */
    @Data
    @EqualsAndHashCode(callSuper = false)
    @ToString
    @NoArgsConstructor
    @AllArgsConstructor
    public class AccountDetail {
        /** 账户ID */
        private Long accountId;
        /** 邮箱 */
        private String email;
    }
    

    账户类引用了账户详情类,如果我们仅仅是浅克隆,那么详情类将不会真正被拷贝,而是拷贝了它的引用。

    测试代码:

    /**
     * 类名 CloneTest
     * 描述 克隆测试类
     */
    public class CloneTest {
        public static void main(String[] args) throws CloneNotSupportedException {
            // 浅克隆证明
            AccountDetail detail = new AccountDetail(1L, "1048791780@qq.com");
            Account account = new Account(1L, "小何", detail);
    
            // 克隆
            Account clone = (Account) account.clone();
    
            // 判断详情对对象是否相同,预期值(true)
            System.out.println(clone.getDetail() == account.getDetail());
        }
    }

    上述代码执行后,结果为true, 表示原始对象和克隆对象的AccountDetail是同一个 引用。也就是说,该对象没有被克隆。如果修改了AccountDetail对象的值,原始对象和克隆对象都将会发生变化。有时候,这可能并不是我们希望看到的。

    所以,我们需要连对象里面的对象也要是一个新的对象。每一个属性都被完全拷贝,这才是深克隆。

     

    二、深克隆

    1、手动为引用属性赋值

    我们修改Account对象的clone方法

    @Override
    public Object clone() throws CloneNotSupportedException {
        Account account = (Account) super.clone();
        // 手动赋值实现深克隆
        account.setDetail(this.getDetail());
        return account;
    }

    然后重新运行上述的测试代码,得出的结论为false,也就是原始对象和克隆对象的AccountDetail是不同的对象。也就实现了深克隆。

    显然,这种手动的方式在关联对象少的情况是可取的,假设关联的对象里面也包含了对象,就需要层层修改,比较麻烦。不推荐这样使用!

    于是,有没有简单的方式呢。当然有,继续往下看!

    2、使用fastJson

    这种方式我们我们依赖于阿里巴巴的fastJSON包。

    public static void main(String[] args) {
        AccountDetail detail = new AccountDetail(1L, "1048791780@qq.com");
        Account account = new Account(1L, "小何", detail);
    
        // fastJson实现克隆
        Account clone = JSONObject.parseObject(JSONObject.toJSONBytes(account), Account.class);
    
        // 判断详情对对象是否相同,预期值(false)
        System.out.println(clone.getDetail() == account.getDetail());
    }

    这种方式和很简单 ,也不需要事先Clonable接口 ,不失为一种好的解决方式。

    3、使用ObjectStream(推荐)

    这就是使用 Java流中的序列化对象事先深克隆。

    奉上一个工具类

    /**
     * 类名 SerialCloneUtils
     * 描述 序列化克隆工具
     *
     * @author hedonglin
     * @version 1.0
     * @date 2019/11/15 16:36
     */
    public class SerialCloneUtils{
        /**
         * 使用ObjectStream序列化实现深克隆
         * @return Object obj
         */
        public static <T extends Serializable> T deepClone(T t) throws CloneNotSupportedException {
            // 保存对象为字节数组
            try {
                ByteArrayOutputStream bout = new ByteArrayOutputStream();
                try(ObjectOutputStream out = new ObjectOutputStream(bout)) {
                    out.writeObject(t);
                }
    
                // 从字节数组中读取克隆对象
                try(InputStream bin = new ByteArrayInputStream(bout.toByteArray())) {
                    ObjectInputStream in = new ObjectInputStream(bin);
                    return (T)(in.readObject());
                }
            }catch (IOException | ClassNotFoundException e){
                CloneNotSupportedException cloneNotSupportedException = new CloneNotSupportedException();
                e.initCause(cloneNotSupportedException);
                throw cloneNotSupportedException;
            }
        }
    }

    可以直接通过工具类来实现克隆,跟上面fastJson使用类似,当然也可以再升级一下,提供一个公共的父类,纪要继承该类就可以实现深克隆。

    /**
     * 类名 SerialClone
     * 描述 序列化克隆类,只有继承该类,就可以实现深克隆
     *
     */
    public class SerialClone implements Cloneable, Serializable {
        private static final long serialVersionUID = 5794148504376232369L;
    
        @Override
        public Object clone() throws CloneNotSupportedException {
            return SerialCloneUtils.deepClone(this);
        }
    }

    改造Account类和AccountDetail类,都继承SerialClone。

    /**
     * 类名 Account
     * 描述 账户类
     */
    @Data
    @EqualsAndHashCode(callSuper = false)
    @ToString
    @NoArgsConstructor
    @AllArgsConstructor
    public class Account /*implements Cloneable*/ extends SerialClone {
        private static final long serialVersionUID = 320551237720888204L;
        /** 主键 */
        private Long id;
        /** 账户名称 */
        private String name;
        /** 账户详情 */
        private AccountDetail detail;
    
    //    @Override
    //    public Object clone() throws CloneNotSupportedException {
    //        Account account = (Account) super.clone();
    //        // 手动赋值实现深克隆
    //        account.setDetail(this.getDetail());
    //        return account;
    //    }
    }
    
    
    /**
     * 类名 AccountDetail
     * 描述 账户详情类
     */
    @Data
    @EqualsAndHashCode(callSuper = false)
    @ToString
    @NoArgsConstructor
    @AllArgsConstructor
    public class AccountDetail extends SerialClone {
        private static final long serialVersionUID = -2232096703114704249L;
        /** 账户ID */
        private Long accountId;
        /** 邮箱 */
        private String email;
    }

    重新运行测试代码,返回值就已经变成了false。

    这种方式,代码虽然多一点,但确实比较高效和容易抽象的,也是很常用的方式!

     

    闲暇之余,记录一下代码!码农就是需要不断学习,不进则退,加油!

    展开全文
  • 序列化和依次克隆各个可变的引用类型都可以实现深克隆,但是序列化的效率并不理想 下面是两种实现深克隆的实例,并且测试类对两种方法进行了对比: 1、重写clone方法使用父类中的clone()方法实现深克隆 ...

    序列化和依次克隆各个可变的引用类型都可以实现深克隆,但是序列化的效率并不理想

    下面是两种实现深克隆的实例,并且测试类对两种方法进行了对比:

    1、重写clone方法使用父类中的clone()方法实现深克隆

    package com.lk.B;
    
    public class Worker implements Cloneable{
    	private String name;
    	private int age;
    	public Worker(String name,int age){
    		this.name = name;
    		this.age = age;
    	}
    	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;
    	}
    	@Override
    	public String toString() {
    		// TODO Auto-generated method stub
    		StringBuffer sb = new StringBuffer();
    		sb.append("姓名:"+name+",");
    		sb.append("年龄:"+age+"\n");
    		return sb.toString();
    	}
    	@Override
    	protected Worker clone() {
    		// TODO Auto-generated method stub
    		Worker worker = null;
    		try {
    			worker = (Worker) super.clone();
    		} catch (CloneNotSupportedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return worker;
    	}
    }
    

      2、重写clone()方法使用序列化方法实现深克隆

    package com.lk.B;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class Employee implements Cloneable,Serializable{
    	private static final long serialVersionUID = 1L;
    	private String name;
    	private int age;
    	public Employee(String name,int age){
    		this.name = name;
    		this.age = age;
    	}
    	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;
    	}
    	@Override
    	public String toString() {
    		// TODO Auto-generated method stub
    		StringBuffer sb = new StringBuffer();
    		sb.append("姓名:"+name+",");
    		sb.append("年龄:"+age+"\n");
    		return sb.toString();
    	}
    	@Override
    	protected Employee clone() {
    		// TODO Auto-generated method stub
    		Employee employss = null;
    		
    		ByteArrayOutputStream baos = new ByteArrayOutputStream();
    		try {
    			ObjectOutputStream oos = new ObjectOutputStream(baos);
    			oos.writeObject(this);
    			oos.close();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    		ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    		try {
    			ObjectInputStream ois = new ObjectInputStream(bais);
    			employss = (Employee) ois.readObject();
    			ois.close();
    		} catch (IOException | ClassNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return employss;
    	}
    }
    

      两者的实现方式在上面已经列出来了

    下面编写了一个测试类来测试两种方式的效率

    package com.lk.B;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class Test3 {
    	public static void main(String[] args) {
    		List<Worker> workerList = new ArrayList<Worker>();//保存Worker对象
    		List<Employee> employeelist = new ArrayList<Employee>();//保存Employee对象
    		Worker worker = new Worker("阿坤", 21);
    		Employee employee = new Employee("阿坤", 21);
    		long time = System.currentTimeMillis();//取得系统当前时间
    		//保存10000个Worker对象复制品到列表
    		for(int i=0;i<10000;i++){
    			workerList.add(worker.clone());
    		}
    		System.out.println("使用复制域的方式实现克隆所花费的时间:"+(System.currentTimeMillis()-time)+"ms");
    		time = System.currentTimeMillis();//取得系统当前时间
    		//保存10000个Employee对象复制品到列表
    		for(int i=0;i<10000;i++){
    			employeelist.add(employee.clone());
    		}
    		System.out.println("使用复制域的方式实现克隆所花费的时间:"+(System.currentTimeMillis()-time)+"ms");
    	}
    }
    

      运行结果:

    /*
    使用复制域的方式实现克隆所花费的时间:4ms
    使用复制域的方式实现克隆所花费的时间:838ms
    */
    

      可以看出,可以使用序列化和逐个复制引用类型域的方式完成深克隆,其中序列化的方式效率很低。

    转载于:https://www.cnblogs.com/luankun0214/p/4398352.html

    展开全文
  • java实现深克隆(如HashMap等)

    千次阅读 2015-01-30 19:59:29
    克隆就是复制一个对象的复本.但一个对象中可能有基本数据类型,如:int,long,float 等,也同时含有非基本数据类型如(数组,集合等) 被克隆得到的对象基本类型的值修改了,原对象的值不会改变.这种适合shadow clone(浅...
  • 一.原型模式介绍A.优点:当创建新的对象实例较为复杂时,使用原型模式可以简化的对象的创建过程,通过复制一个已有实例可以提高新实例的...而且这个克隆方法需要对类的功能进行通盘考虑,这对全新的类来说不是很难...
  • java实现深克隆(deep clone)

    千次阅读 2009-10-18 15:27:00
    克隆就是复制一个对象的复本.但一个对象中可能有基本数据类型,如:int,long,float 等,也同时含有非基本数据类型如(数组,集合等)被克隆得到的对象基本类型的值修改了,原对象的值不会改变.这种适合shadow clone(浅克隆...
  • 本文详细介绍了Java中的浅克隆和深克隆的概念,及案例演示如何实现深克隆
  • 详细介绍了Java序列化流ObjectOutputStream、ByteArrayInputStream,内存操作流ByteArrayOutputStream、ByteArrayInputStream,以及实现深克隆
  • Java 序列化方式实现深克隆

    千次阅读 2017-10-09 12:22:14
    // 用序列化与反序列化实现深克隆 private Object deepClone(Object src) { Object o = null; try { if (src != null) { ByteArrayOutputStream baos = new B
  • 深克隆(深拷贝) 指的是在复制java对象的时候java对象中的值不共享 浅克隆(浅拷贝) 指的是在复制java对象的时候java对象中的值共享 也就是说,如果我们需要完全复制出一个新的对象,我们需要重写clone方法 ...
  • Java浅克隆与深克隆

    万次阅读 2019-11-10 22:52:42
    然而Java早已考虑好一切,我们知道,所有的对象都有一个共同的父类Object,而Object类中已经定义好了protected修饰的clone()方法,今天我们从这个方法开始,讲述Java的浅克隆与深克隆。 浅克隆与深克隆的区别 **浅...
  • 话不多说,下面讲一下深度克隆,深克隆实现相对简单一点,只需要被克隆的对象实现Serializable接口,克隆的过程相对比较通用 被克隆对象: import java.io.Serializable; public class SerialCar implements ...
  • java——深克隆

    2019-03-02 19:43:55
    2,实现深克隆的步骤 (1):实现Cloneable接口 (2):重写clone()方法 (3):先实现浅克隆 例如:Employee emp = (Employee)super.clone(); (4)再在浅克隆的基础上,进一步克隆需要的成员变量(引用类型)...
  • Java -克隆实现方式 深克隆与浅克隆

    千次阅读 2018-05-10 16:43:43
    我们平时复制一个值类型数据直接复制就好了,但是复制一个引用类型比如...克隆类型在Java语言中,数据类型分为值类型(基本数据类型)和引用类型,值类型包括int、double、byte、boolean、char等简单数据类型,引用类
  • 在学习编程的过程中,我觉得不止要获得课本的知识,更多的是通过学习技术知识提高解决问题的能力,这样我们才能走在最前方,本文主要讲述java使用序列化实现深克隆,更多Java专业知识,广州疯狂java培训官网与你分享...
  • Java深克隆与浅克隆

    2019-04-23 20:04:59
    浅克隆和深克隆的主要区别在于潜克隆复制的时候如果是值类型则直接克隆,而如果是引用类型则不会克隆对象引用的对象,而只是简单地复制这个引用。也就是说如果修改克隆后的对象中的引用类型数据,原对象中也会更改,...
  • Java 深克隆&浅克隆

    2020-12-22 16:17:52
    --实现深克隆 需求 Sunny 软件公司 OA 系统支持工作周报的快速克隆,极大提高了工作周报的编写效率,受到员工的一致好评。 Java 深克隆(DeepClone)与浅克隆(ShallowClone)是原型设计模式的灵魂。 记录结构: --...
  • import java.io.Serializable; import java.util.Date; public class Sheep implements Serializable{ private String name; private Date createTime; public Sheep(String name, Date createTime) { this....

空空如也

空空如也

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

java实现深克隆

java 订阅