Java对象的拷贝

最新推荐文章于 2024-01-29 16:49:32 发布

angle_sun

最新推荐文章于 2024-01-29 16:49:32 发布

阅读量504

点赞数 1

分类专栏： java 文章标签： java 对象赋值

本文链接：https://blog.csdn.net/angle_sun/article/details/51319155

版权

java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

积累方能进步

概括

在java中，我们都知道对象之间的传递，分为值传递和引用传递。值传递没有什么好说的，就是将变量的值直接赋值给另一个变量。但是引用传递就比较复杂（在java中并没用明显的引用传递，对象之间的引用传递可以理解为直接传递的地址）。
当传递的是一个类似于地址的东西时，这个时候我们将一个对象赋值于另一个对象的时候，这两个对象所指向的内存地址是同一块。当其中一个的值发生改变的时候，另一个对象所指定的内容也会改变。而如果我们不想要两个变量之间的关系如此的紧密，而想当一个对象的属性改变时，另一个变量的同一个属性不做改变。这个时候就需要想其它办法实现，直接将对象赋值明显是行不通的。

解决方案

解决方案分为两种，第一种为浅复制，另一种为深复制。顾名思义，浅复制复制的没有深复制那么的全面。浅复制可以解决简单的复制，但是不能解决对象里面的属性也是对象的属性的复制，用浅复制的话依然是”引用“。但是如果用深复制的话，则对象里面的所有属性，都会有一个新的备份。

浅复制

在Java中的object类中有一个方法，方法名为object clone()。这个名字可以很清楚地看出，这是一个克隆，也就是复制。不过Java语言提供给我们的是一个浅复制，只能复制对象属性中值类型的传递。代码如下：

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private int i;
    public void setI(int i)
    {
        this.i = i;
    }
    public int getI()
    {
        return this.i;
    }

    private man m;

    public void setM(man m)
    {
        this.m = m;
    }
    public man getM()
    {
        return this.m;
    }

      public Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
}

public class man implements Serializable,Cloneable{ 
    private static final long serialVersionUID = 1L;
    private int m;
    public void setM(int m)
    {
        this.m = m;
    }
    public int getM()
    {
        return this.m;
    }
}

public static void main(String[] args) throws CloneNotSupportedException {

        Person p = new Person();
        man m = new man();
        p.setI(1);
        m.setM(1);
        p.setM(m);
        Person p1 = new Person();
        p1 = p;

        System.out.println(p.getI());
        System.out.println(p1.getI());
        System.out.println("p.m"+p.getM().getM());

        Person p2 = (Person)p1.clone();
        p2.setI(3);
        p2.getM().setM(3);
        p1.setI(2);
        System.out.println(p.getI());
        System.out.println(p1.getI());
        System.out.println(p2.getI());
        System.out.println("p.m"+p.getM().getM());
        System.out.println("p2.m"+p2.getM().getM());

    }

结果如下：

这里写图片描述

结果分析：

从前两个输出的1是，是对p的i属性赋值的1，第三份p.m1是对m这个属性的m属性赋值的1。接着将p1浅赋值给p2，所以这个时候p2的m属性的m属性的值为1。因为是浅赋值，所以当改变p2的i属性的时候，p1的i属性不会受到影响，当改变p2的m属性的时候，p1的m属性也会受到影响。所以当将p2的i值改为3时，p2的m属性的m属性改为3时，出现了后面的结果。

深复制

深复制的实现由多种方法，我们可以在每一个我们定义的类里面都定一个浅复制。因为任何一个类里面的属性归根到底都是java定义的基础类型，所以用浅复制理论上是可以全部都进行复制的。当一个类的属性中定义的有其它类的变量，这个时候我们就是需要对这个属性也进行浅复制，需要将它抽离出来。因为这个和浅复制相差无几，所以就不具体分析。

另一种方法是对类进行序列化，进行了序列化之后，我们就可以将对象存到内存中，然后将对象输出来。这样，这两个对象所指向的内存就不一样，虽然里面的值都是相同的，但是相互之间已经没有了联系。通过这种方法我们可以延伸用json进行赋值等等。序列化的代码如下：

只用将类person里面的Clone方法改为如下：

 public Object clone() throws CloneNotSupportedException {
           // return super.clone();
          try
          {
           ByteArrayOutputStream bo = new ByteArrayOutputStream();
           ObjectOutputStream oo = new ObjectOutputStream(bo);
           oo.writeObject(this);

           ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
           ObjectInputStream oi = new ObjectInputStream(bi);
           return oi.readObject();
          }
          catch(Exception e1)
          {
             e1.printStackTrace();  
             return null;
          }
        }