美文网首页
Java解惑之深拷贝or浅拷贝

Java解惑之深拷贝or浅拷贝

作者: sofarsogoo_932d | 来源:发表于2018-04-01 10:55 被阅读0次

    在说这个问题之前,先看一段代码

    public class Person {
      public int num;
      public String name;
    }
    
    public class Test4 {
      public static void main(String[] args) {
        Person p1 = new Person();
        p1.num = 001;
        p1.name = "张三";
        Person p2 = p1;         //关注点1
        p2.name="李四";
        System.out.println(p1 == p2);
        System.out.println(p1.name);
      }
    }
    

    输出结果

    true
    李四
    

    结果分析
    关注点1这句代码,是将p1对象的引用(地址)拷贝给了p2,因此p1和p2指向同一个地址,p2对这个地址对应的区域做了修改,p1访问这个地址时当然拿到的是修改后的内容。

    调用clone方法
    上代码之前,先说下调用该代码的必备条件
    实现Cloneable接口,否则会抛CloneNotSupportedException异常
    重写Object类的clone方法,否则调用不到该方法
    这里有几个疑问
    Object类的clone方法明明是protected的,为什么子类调不到?
    网上说的要将clone方法声明为public?

    修改代码如下

    public class Book {
      public String name;
    }
    
    public class Person implements Cloneable{
        public int num;
        public String name;
        public Book book;
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        return super.clone();
      }
    }
    
    public class Test4 {
    
      public static void main(String[] args) throws CloneNotSupportedException {
    
        //p1的属性
        Person p1 = new Person();
        Book book=new Book();
        book.name="算法导论";
        p1.num = 001;
        p1.name = "张三";
        p1.book=book;
        
        //p2的属性
        Person p2 = (Person) p1.clone();
        p2.name="李四";
        p2.book.name="操作系统";
        System.out.println(p1 == p2);
        System.out.println(p1.name);
        System.out.println(p1.book==p2.book);
        System.out.println(p1.book.name);
    
      }
    }
    

    输出结果

    false
    张三
    true
    操作系统
    

    结果分析
    p2是p1的一个克隆,故p1和p2此时指向不同的地址
    在克隆的时候,String类型和基本类型一样都会被克隆
    因为Book是自定义的对象,故无法实现克隆(深拷贝),即p1和p2中的book对象指向的是同一个地址。

    不过这里我还有个疑问
    String类也是对象类型的,它没有实现Clonable接口,也没有重写clone方法,是如何实现克隆的了?

    为了实现彻底的克隆,我们来修改下Book和Person的代码

    public class Person implements Cloneable{
        public int num;
        public String name;
        public Book book;
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        Person p=(Person) super.clone();
        p.book=(Book) book.clone();
        return p;
      }
    }
    
    public class Book implements Cloneable{
        public String name;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        return super.clone();
        }
    }
    

    输出结果

    false
    张三
    false
    算法导论
    

    结果分析
    在Person类的clone方法中,增加了book对象的克隆,因此p1和p2的book对象不再指向同一个地址了。

    结论
    Object类的clone方法只会对基本类型(对应的包装类)和String类型进行深拷贝,对于普通对象只是复制一下地址。
    包装类虽然没有测试,但发现包装类是final型的,不可能继承重写clone方法,因此猜测它和String类一样是深拷贝。
    想要完成彻底的深拷贝,需要对本类中的其他普通类依次调用它们的clone方法。

    看了上面的叙述,不知道你是否会想,那如果我的A类包含B类,B类又包含C类.......,这样就需要对每一个类都做相应的处理,这样岂不是很费劲?别着急,下面我来介绍一下Serializable

    Serializable深拷贝

    public class Book1 implements Serializable{
        private static final long serialVersionUID = 1L;
        public String name;
    }
    
    public class Student implements Serializable{
        private static final long serialVersionUID = 1L;
    
        public int num;
        public String name;
        public Book1 book;
    }
    
    public static Object deepCopy(Object object){
        ByteArrayOutputStream bo=null;
        ObjectOutputStream oo=null;
        ByteArrayInputStream bi=null;
        ObjectInputStream oi=null;
        Object obj=null;
        try {
            //将对象写入流
            bo=new ByteArrayOutputStream();
            oo=new ObjectOutputStream(bo);
            oo.writeObject(object);
            
            //从流中读取对象
            bi=new ByteArrayInputStream(bo.toByteArray());
            oi=new ObjectInputStream(bi);
            obj=oi.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                if(oi!=null)
                oi.close();
                if(bi!=null)
                    bi.close();
                if(oo!=null)
                    oo.close();
                if(bo!=null)
                    bo.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }   
        }
        return obj;
    }
    
    public class Test5 {
    
       public static void main(String[] args) {
    
        // s1的属性
        Student s1 = new Student();
        Book1 book = new Book1();
        book.name = "算法导论";
        s1.num = 001;
        s1.name = "张三";
        s1.book = book;
    
        // s2的属性
        Student s2 =(Student) Utils.deepCopy(s1);
        s2.name = "李四";
        s2.book.name = "操作系统";
        System.out.println(s1 == s2);
        System.out.println(s1.name);
        System.out.println(s1.book == s2.book);
        System.out.println(s1.book.name);
      }
    }
    

    输出结果

    false
    张三
    false
    算法导论
    

    结果分析
    此结果与上面对person和book分别调用clone方法一致,说明serializable能够对对象做深拷贝,无论该对象里是否有其他普通对象。

    回到最初的问题
    浅拷贝,对于引用类型,只是对地址做了拷贝,即copy前后的对象指向的是同一块内存空间。
    深拷贝,对于引用类型,会在内存空间新开辟一块空间,并将被拷贝的对象的相关属性一一复制在新的内存空间内,即copy前后的对象指向的是不同的内存空间。

    相关文章

      网友评论

          本文标题:Java解惑之深拷贝or浅拷贝

          本文链接:https://www.haomeiwen.com/subject/sgkncftx.html