java 对象的克隆(浅克隆和深克隆)

java 对象的克隆

一、对象的浅克隆

(1)需要克隆类需要重写Object类的clone方法,并且实现Cloneable接口(标识接口,无需实现任何方法)
(2)当需要克隆的对象中维护着另外一个引用对象,浅克隆不会克隆另外一个引用对下,而是直接复制维护的另外一个引用对象的地址。
(3)对象的浅克隆也不会调用到构造方法。

以下为对象的浅克隆的一个例子:

package com.clone;

import java.io.Serializable;

/**
 * Description:
 * 实现了Cloneable接口,并重写Object类的clone方法。
 *
 * @author lee
 * */
public class CloneDemo1 implements Cloneable,Serializable{

  //该克隆类封装的信息
  public int id;
  public String name;
  public Address address;

  /**
   * Desciption:
   * 默认构造器
   *
   * */
  public CloneDemo1(){}

  /**
   * Description:
   * 初始化id,name的构造器
   *
   * @param id id
   * @param name 名字
   * @param address 地址
   * */
  public CloneDemo1(int id, String name, Address address){
    this.id=id;
    this.name=name;
    this.address = address;
  }

  /**
   * Descriptin:
   * 重写Object类的clone方法。
   * if the object's class does not support the Cloneable interface.
   * Subclasses that override the clone method can also throw this exception
   * to indicate that an instance cannot be cloned.
   *
   * @throws CloneNotSupportedException
   * */
  @Override
  public Object clone() throws CloneNotSupportedException{
    return super.clone();
  }

  /**
   * Description:
   * 重写toString方法
   *
   * @return "id="+id+", name="+name
   * */
  @Override
  public String toString(){
    return "id="+id+", name="+name+", address:"+address.getAddress();
  }

  /**
   * Description:
   * 主方法
   *
   * */
  public static void main(String[] args) throws CloneNotSupportedException{

    CloneDemo1 c1 = new CloneDemo1(1,"c1",new Address("北京"));
    //c2 复制了c1的地址,并没有复制整个c1对象
    CloneDemo1 c2 = c1;
    //c3 对象的浅克隆,复制了整个对象
    CloneDemo1 c3 = (CloneDemo1)c1.clone();

    //当对象c1改变其name或者id的时候,c2也会自动改变。
    //因为c2只是复制了c1的地址,并非复制了c1的整个对象。
    //相应的c3则不会随着c1改变而改变,意味着c3将c1整个对象克隆一份出来。

    //当是,对象的浅克隆不会克隆被克隆对象当中的引用对象。
    //因此c1改变其中的Address的引用对象时,c2,c3也会跟着改变。
    c1.setName("cc");
    c1.address.setAddress("上海");
    System.out.println(c1+"\n"+c2+"\n"+c3);

  }

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

}

/**
 * Description:
 * 一个封装着地址的类
 *
 * @author lee
 * */
class Address implements Serializable{
  public String address;

  /**
   * Description:
   * 默认构造器
   *
   * */
  public Address(){}

  /**
   * Description:
   * 初试化address
   *
   * @param address 地址
   * */
  public Address(String address){
    this.address = address;
  }

  //address的set和get方法
  public String getAddress() {
    return address;
  }

  public void setAddress(String address) {
    this.address = address;
  }
}

二、对象的深克隆

就是利用对象的输入输出流把对象写到文件上,再读取对象的信息,这就是对象的深克隆。

由于对象的浅克隆不会克隆被克隆对象其中的引用对象,而是直接复制其地址。因此,要克隆被克隆对象当中的引用类型则需要对象的深克隆。

而对象的深克隆使用的的对象序列化输入输出。

代码如下:

package com.clone;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * Description:
 * 实现对象的深克隆
 *
 * @author lee
 * */
public class CloneDemo2 {

  /**
   * Description:
   * 将对象输出到一个文件当中。
   *
   * @param c 需要被写到文件当中的对象。
   * */
  public static void writeObject(CloneDemo1 c){

    ObjectOutputStream out = null;
    try{

      //将对象输出在一个object.txt文件当中
      out = new ObjectOutputStream(new FileOutputStream("./object.txt"));
      out.writeObject(c);

    }catch(IOException e){
      System.out.println("写入对象的时候发生了错误。");
      e.printStackTrace();
    }finally{

      //关闭资源
      try{
        out.close();
      }catch(IOException e){
        e.printStackTrace();
      }
    }

  }

  /**
   * Description:
   * 从文件中读取出一个对象来,并返回。
   *
   * @return c 返回一个对象。
   * */
  public static CloneDemo1 readObject(){

    CloneDemo1 c = null;
    ObjectInputStream input = null;
    try{
      //从object.txt文件中读取一个对象出来
      input = new ObjectInputStream(new FileInputStream("./object.txt"));
      c = (CloneDemo1)input.readObject();

    }catch(IOException | ClassNotFoundException e){
      e.printStackTrace();
      System.out.println("读取对象的时候发生了错误。");
    }finally{
      //关闭资源
      try{
        input.close();
      }catch(IOException e){
        e.printStackTrace();
      }
    }
    return c;
  }
  /**
   * Description:
   * 主方法
   *
   * @throws CloneNotSupportedException
   * */
  public static void main(String[] args) throws CloneNotSupportedException {
    CloneDemo1 c1 = new CloneDemo1(1,"c1",new Address("北京"));
    //c2 对象的浅克隆
    CloneDemo1 c2 = (CloneDemo1)c1.clone();
    //c3对象的深克隆
    writeObject(c1);
    CloneDemo1 c3 = readObject();

    //因为对象的深克隆同时也克隆了被克隆对象维护的另外一个对象
    //所以,当c1改变其当中的维护的另外一个对象的时候,c3不会随之改变。
    //而c2位浅克隆,其维护的另外一个对象只是复制了c1维护的对象的地址,因此会随着c1的改变而改变。
    c1.address.setAddress("上海");
    System.out.println(c1+"\n"+c2+"\n"+c3);

  }

}

对象的序列化,是需要实现Serializable接口的。

感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

(0)

相关推荐

  • java中List对象列表实现去重或取出及排序的方法

    前言 因为在面试的时候碰到几次list的去重和排序,觉着有必要给大家总结一下具体的方法,分享出来供大家学习参考,话不多说了,来一起看看下面介绍的一种做法: 一.list去重 1.1 实体类Student List<Student>容量10k以上,要求去重复.这里Student的重复标准是属性相同,因此需要重写equals和hashcode方法,不知道有几个可以手写出来. student的equals方法: public void equals(Object o){ if(this == o)

  • Java对象的序列化与反序列化详解

    一.序列化和反序列化的概念 把对象转换为字节序列的过程称为对象的序列化,把字节序列恢复为对象的过程称为对象的反序列化. 对象的序列化主要有两种途径: Ⅰ . 把对象的字节序列永久地保存到硬盘上,通常存放在一个文件中 Ⅱ.  在网络上传送对象的字节序列. 当两个进程在进行远程通信时,彼此可以发送各种类型的数据.无论是何种类型的数据,都会以二进制序列的形式在网络上传送.发送方需要把这个Java对象转换为字节序列,才能在网络上传送:接收方则需要把字节序列再恢复为Java对象. 二.序列化API 1.

  • Java编程思想对象的容纳实例详解

    Java提供了容纳对象(或者对象的句柄)的多种方式,接下来我们具体看看都有哪些方式. 有两方面的问题将数组与其他集合类型区分开来:效率和类型.对于Java来说,为保存和访问一系列对象(实际是对象的句柄)数组,最有效的方法莫过于数组.数组实际代表一个简单的线性序列,它使得元素的访问速度非常快,但我们却要为这种速度付出代价:创建一个数组对象时,它的大小是固定的,而且不可在那个数组对象的"存在时间"内发生改变.可创建特定大小的一个数组,然后假如用光了存储空间,就再创建一个新数组,将所有句柄从

  • java 对象输入输出流读写文件的操作实例

    java 对象输入输出流读写文件的操作实例 java 支持对对象的读写操作,所操作的对象必须实现Serializable接口. 实例代码: package vo; import java.io.Serializable; public class Animal implements Serializable { private static final long serialVersionUID = 1L; private String name; private Integer weight;

  • HttpServletRequest对象简介_动力节点Java学院整理

    通过getMethod方法获得的是客户端访问该web应用的Http请求方式. 代码和结果如下: String requestMethod = request.getMethod(); System.out.println(requestMethod); 想获取客户端发来的HTTP请求头中的内容可以使用如下方法: getDateHeader() getHeader(String) getHeaderNames() getHeaders(String) getIntHeader(String); 这

  • java 对象的克隆(浅克隆和深克隆)

    java 对象的克隆 一.对象的浅克隆 (1)需要克隆类需要重写Object类的clone方法,并且实现Cloneable接口(标识接口,无需实现任何方法) (2)当需要克隆的对象中维护着另外一个引用对象,浅克隆不会克隆另外一个引用对下,而是直接复制维护的另外一个引用对象的地址. (3)对象的浅克隆也不会调用到构造方法. 以下为对象的浅克隆的一个例子: package com.clone; import java.io.Serializable; /** * Description: * 实现了

  • 深入了解Java对象的克隆

    今天要介绍一个概念,对象的克隆.本篇有一定难度,请先做好心理准备.看不懂的话可以多看两遍,还是不懂的话,可以在下方留言,我会看情况进行修改和补充. 克隆,自然就是将对象重新复制一份,那为什么要用克隆呢?什么时候需要使用呢?先来看一个小栗子: 简单起见,我们这里用的是Goods类的简单版本. public class Goods { private String title; private double price; public Goods(String aTitle, double aPri

  • 基于序列化存取实现java对象深度克隆的方法详解

    我们知道,在java中,将一个非原型类型类型的对象引用,赋值给另一个对象的引用之后,这两个引用就指向了同一个对象,如: 复制代码 代码如下: public class DeepCloneTest { private class CloneTest {  private Long myLong = new Long(1); } public static void main(String args[]) {  new DeepCloneTest().Test(); } public void Te

  • 深入JAVA对象深度克隆的详解

    有时候,我们需要把对象A的所有值复制给对象B(B = A),但是这样用等号给赋值你会发现,当B中的某个对象值改变时,同时也会修改到A中相应对象的值!也许你会说,用clone()不就行了?!你的想法只对了一半,因为用clone()时,除了基础数据和String类型的不受影响外,其他复杂类型(如集合.对象等)还是会受到影响的!除非你对每个对象里的复杂类型又进行了clone(),但是如果一个对象的层次非常深,那么clone()起来非常复杂,还有可能出现遗漏!既然用等号和clone()复制对象都会对原来

  • Java中对象的深复制(深克隆)和浅复制(浅克隆)介绍

    1.浅复制与深复制概念 ⑴浅复制(浅克隆) 被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象.换言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象. ⑵深复制(深克隆) 被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量.那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象.换言之,深复制把要复制的对象所引用的对象都复制了一遍. 2.Java的clone()方法 ⑴clone方法将对象复制了一份并返回

  • 实例分析java对象中浅克隆和深克隆

    引言: 在Object基类中,有一个方法叫clone,产生一个前期对象的克隆,克隆对象是原对象的拷贝,由于引用类型的存在,有深克隆和浅克隆之分,若克隆对象中存在引用类型的属性,深克隆会将此属性完全拷贝一份,而浅克隆仅仅是拷贝一份此属性的引用.首先看一下容易犯的几个小问题 clone方法是Object类的,并不是Cloneable接口的,Cloneable只是一个标记接口,标记接口是用用户标记实现该接口的类具有某种该接口标记的功能,常见的标记接口有三个:Serializable.Cloneable

  • JAVA 对象创建与对象克隆

    目录 一.对象的4种创建方式 二.通过new创建对象 三.反射 四.克隆对象 浅拷贝 深拷贝 五.反序列化 六.补充 一.对象的4种创建方式 new 创建 反射 克隆 反序列化 二.通过new创建对象 一般情况下,对象通过new 关键字创建,首先会在堆上给对象分配空间,然后执行构造函数进行一系列的初始化,在分配的内存空间上为一众属性赋值:完成初始化后再将堆区对象的引用传递给栈区,最终参与程序的运行. 三.反射 调用Java.lang.Class或者java.lang.reflect.Constr

  • Java对象的复制三种方式(小结)

    1.概述 在实际编程过程中,我们常常要遇到这种情况:有一个对象A,在某一时刻A中已经包含了一些有效值,此时可能 会需要一个和A完全相同新对象B,并且此后对B任何改动都不会影响到A中的值,也就是说,A与B是两个独立的对象,但B的初始值是由A对象确定的.例如下面程序展示的情况: class Student { private int number; public int getNumber() { return number; } public void setNumber(int number)

  • 深入理解Java中的克隆

    前言 Java克隆(Clone)是Java语言的特性之一,但在实际中应用比较少见.但有时候用克隆会更方便更有效率. 对于克隆(Clone),Java有一些限制: 1.被克隆的类必须自己实现Cloneable 接口,以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制.Cloneable 接口实际上是个标识接口,没有任何接口方法. 2.实现Cloneable接口的类应该使用公共方法重写 Object.clone(它是受保护的).某个对象实现了此接口就克隆它是不可能的.即使

  • java对象拷贝详解及实例

    java对象拷贝详解及实例 Java赋值是复制对象引用,如果我们想要得到一个对象的副本,使用赋值操作是无法达到目的的: @Test public void testassign(){ Person p1=new Person(); p1.setAge(31); p1.setName("Peter"); Person p2=p1; System.out.println(p1==p2);//true } 如果创建一个对象的新的副本,也就是说他们的初始状态完全一样,但以后可以改变各自的状态,

随机推荐