对基本类型的变量进行拷贝非常简单,直接赋值给另外一个对象即可:

 int b = 50;
int a = b; // 基本类型赋值

对于引用类型的变量(例如 String),情况稍微复杂一些,因为直接等号赋值只是复制了一份引用,而复制前后的两个引用指向的是内存中的同一个对象。

要想实现引用类型的拷贝,可以通过实现 Cloneable 接口,并覆盖其中的 clone 方法来实现。

看一个例子,首先定义一个待拷贝的 Student 类,为简单起见,只设置了一个 name 属性

 class Student implements Cloneable{
private String name; public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} @Override
public Object clone(){
Student s = null;
try{
s = (Student)super.clone();
}catch(Exception e){
e.printStackTrace();
}
return s;
}
}

Student

可以看到,在 clone 方法里实际上是调用了 super.clone() 方法

接下来对这个类进行复制,只需要调用 clone 方法即可:

 public void deepCopy(){
Student s1 = new Student();
s1.setName("zhang"); Student s2 = (Student) s1.clone();
s1.setName("wang");
System.out.println(s1.getName());
System.out.println(s2.getName());
}

deepCopy

输出结果为:

wang
zhang

由于s1修改了name属性值,输出的结果中s1和s2的name属性并不相同,说明这两个引用指向了不同的 Student 对象,实现了对象拷贝。

但是,如果在Student中间添加一个引用对象,那么这种拷贝方式就会产生问题。

为了说明问题,定义一个Car类,同样只有一个name属性:

 class Car{
private String name; public String getName() {
return name;
} public void setName(String name) {
this.name = name;
}
}

Car类定义

对 Student 类进行修改,添加一个 Car 类型的属性(略去这部分代码),在 deepCopy 方法里面对 Car 的 name 值进行修改,如下:

 public void deepCopy(){
Student s1 = new Student();
s1.setName("zhang");
Car car = new Car();
car.setName("Audi");
s1.setCar(car); Student s2 = (Student) s1.clone();
s1.setName("wang");
car.setName("BMW");
System.out.println(s1.getName());
System.out.println(s2.getName());
System.out.println(s1.getCar().getName());
System.out.println(s2.getCar().getName());
}

修改后的deepCopy

修改后的输出结果如下:

wang
zhang
BMW
BMW

我们发现,对于 Car 类型的复制出现了问题,s1 和 s2 的Car属性的 name 值是相同的,都是修改后的 BMW,可以推测 s1 和 s2 的 Car 属性指向了内存中的同一个对象。通过s1.getCar() == s2.getCar() 进行验证,输出为 true,说明确实引用了同一个对象。

出现问题的原因是,上面的方法是浅拷贝方法。所谓浅拷贝,是指拷贝对象的时候只是对其中的基本类型属性进行复制,而并不拷贝对象中的引用属性。而我们想要实现的效果是连同 Student 中的引用类型属性一起复制,这就是深拷贝。深拷贝是一个整个独立的对象拷贝,深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大

为了解决这个问题,一种可行的方式是让 Car 类也实现 Cloneable 接口,并覆盖 clone 方法,在 Student 类的 clone 方法里加上一行代码:

this.car = (Car)car.clone()

这样的确能够解决 Car 没有复制的问题,然而如果 Student 中有多个引用类型属性,这些对象有可能也会有其他的引用类型属性,那么上面这种做法就要去所有的相关类都要实现 Cloneable 接口,并覆盖 clone 方法,不仅麻烦,而且非常不利于后期维护和扩展。

一种比较优雅的做法是利用 Java 的序列化和反序列化实现深拷贝。序列化是指将对象转换成字节序列的过程,反序列化是指将字节序列还原成对象的过程。一般在对象持久化保持或者进行网络传输的时候会用到序列化。【需要注意的是 static 和 transient 类型的变量不会被序列化】

利用序列化和反序列化进行深拷贝比较简单,只需要实现 Serializable 接口就行。我们对Student类就行修改,如下:

 class Student implements Serializable{

     //private static final long serialVersionUID = 1L;

     private String name;
private Car car; public Car getCar() {
return car;
} public void setCar(Car car) {
this.car = car;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
}
}

修改后的Student

这里暂时忽略其中的 serialVersionUID 属性,让Car类也同样实现 Serializable 接口,之后定义一个深拷贝的方法:

 public void deepCopyWithSerialize(){
Student s1 = new Student();
s1.setName("zhang111");
Car car = new Car();
car.setName("Audi");
s1.setCar(car); ObjectOutputStream oo;
try {
oo = new ObjectOutputStream (new FileOutputStream("a.txt"));
oo.writeObject(s1);
oo.close(); ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
Student s2 = (Teacher) ois.readObject(); s1.setName("wahah");
car.setName("BMW");
System.out.println(s1.getName());
System.out.println(s2.getName());
System.out.println(s1.getCar().getName());
System.out.println(s2.getCar().getName());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} }

deepCopyWithSerialize

输出结果为:

wahah
zhang111
BMW
Audi

输出结果

可以看出,成功实现了对象的深拷贝。这里选择了利用文件来保存序列化的对象,也可以选择其他的形式,例如 ByteArrayOutputStream

 ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(s1); // 从流中读出对象
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais)
Student s2 = ois.readObject();

ByteArrayOutputStream序列化

接下来解释一下刚才忽略的 serialVersionUID,根据名字知道这是一个与对象的状态有关的变量,如果代码中没有定义这样的变量,那么在运行的时候会按照一定的方式自动生成,在反序列化的时候会对这个值进行判断,如果两个值不相等,会抛出 InvalidClassException 。由于计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性,一般建议在序列化的时候主动提供这个参数。

【总结】

① Cloneable 接口的 clone 方法默认是浅拷贝,需要自行覆盖才能实现深拷贝。

② 使用 Serializable 序列化的方式实现深拷贝比较简单,但是需要注意定义 serialVersionUID 的值,并且 static 和 transient 类型的变量不会被序列化。

【参考资料】

本文的内容主要参考了以下的博客,在此表示感谢

Benson的专栏-Java如何复制对象

田木木-深克隆

请叫我大师兄-Java 之 Serializable 序列化和反序列化的概念,作用的通俗易懂的解释

Java中的关键字 transient

Java序列化之排除被序列化字段(transient/静态变量)

Java深拷贝与序列化的更多相关文章

  1. Java 深拷贝和浅拷贝 利用序列化实现深拷贝

    Java 深拷贝和浅拷贝 转自:http://www.cnblogs.com/mengdd/archive/2013/02/20/2917971.html 深拷贝(deep clone)与浅拷贝(sh ...

  2. 【Java基础】序列化与反序列化深入分析

    一.前言 复习Java基础知识点的序列化与反序列化过程,整理了如下学习笔记. 二.为什么需要序列化与反序列化 程序运行时,只要需要,对象可以一直存在,并且我们可以随时访问对象的一些状态信息,如果程序终 ...

  3. 一种c#深拷贝方式完胜java深拷贝(实现上的对比)

    楼主是一名asp.net攻城狮,最近经常跑java组客串帮忙开发,所以最近对java的一些基础知识特别上心.却遇到需要将一个对象深拷贝出来做其他事情,而原对象保持原有状态的情况.(实在是不想自己new ...

  4. java 深拷贝与浅拷贝机制详解

    概要: 在Java中,拷贝分为深拷贝和浅拷贝两种.java在公共超类Object中实现了一种叫做clone的方法,这种方法clone出来的新对象为浅拷贝,而通过自己定义的clone方法为深拷贝. (一 ...

  5. 对Java Serializable(序列化)的理解和总结

    我对Java Serializable(序列化)的理解和总结 博客分类: Java技术 JavaOSSocketCC++  1.序列化是干什么的?       简单说就是为了保存在内存中的各种对象的状 ...

  6. java.io.Serializable 序列化问题

    java.io.Serializable 序列化问题 Person.java package a.b.c; public class Person implements java.io.Seriali ...

  7. java对象的序列化与反序列化使用

    1.Java序列化与反序列化  Java序列化是指把Java对象转换为字节序列的过程:而Java反序列化是指把字节序列恢复为Java对象的过程. 2.为什么需要序列化与反序列化 我们知道,当两个进程进 ...

  8. Java transient关键字序列化时使用小记

    1. transient的作用及使用方法 我们都知道一个对象只要实现了Serilizable接口,这个对象就可以被序列化,java的这种序列化模式为开发者提供了很多便利,我们可以不必关系具体序列化的过 ...

  9. 【Java】Java原生的序列化和反序列化

    写一个Java原生的序列化和反序列化的DEMO. 需序列化的类: package com.nicchagil.nativeserialize; import java.io.Serializable; ...

随机推荐

  1. Go orm框架gorm学习

    之前咱们学习过原生的Go连接MYSQL的方法,使用Go自带的"database/sql"数据库连接api,"github.com/go-sql-driver/mysql& ...

  2. 【Kubernetes 系列五】在 AWS 中使用 Kubernetes:EKS

    目录 1. 概述 2. 版本 3. 预备 3.1. 操作环境 3.2. 角色权限 3.2.1. CloudFormation 完全权限 3.2.2. EKS 读写权限 3.2.3. EC2 相关权限 ...

  3. Redis回顾

    之前有两篇文章着重介绍了redis集群的搭建和redis与spring的整合,一个月过去了,现在有些忘记了,今天又拿过来稳固一下,发现有很多的东西都忘记了. 资料汇总下载 首先安装ruby环境 安装过 ...

  4. Spark 系列(十五)—— Spark Streaming 整合 Flume

    一.简介 Apache Flume 是一个分布式,高可用的数据收集系统,可以从不同的数据源收集数据,经过聚合后发送到分布式计算框架或者存储系统中.Spark Straming 提供了以下两种方式用于 ...

  5. Spark 系列(十六)—— Spark Streaming 整合 Kafka

    一.版本说明 Spark 针对 Kafka 的不同版本,提供了两套整合方案:spark-streaming-kafka-0-8 和 spark-streaming-kafka-0-10,其主要区别如下 ...

  6. 网络安全攻击与防护--HTML学习

    第一节. HTML基本语法(文末有对该文视频讲解) HTML的官方介绍什么的我就不说了,打字也挺累的,只简单介绍一下吧,其他的懂不懂都没关系. HTML全称为Hypertext Markup Lang ...

  7. npm执行命令行报错

    今天在学习react-router时候使用命令npm start 报了一个错误 npm ERR! missing script: start npm ERR! A complete log of th ...

  8. 多线程之pthread, NSThread, NSOperation, GCD

    关于多线程会有一系列如下:多线程之概念解析 多线程之pthread, NSThread, NSOperation, GCD 多线程之NSThread 多线程之NSOperation 多线程之GCD p ...

  9. springboot 项目的https的发布

    1.生成密钥证书 生成命令: keytool -genkey -alias tomcat -storetype PKCS12 -keyalg RSA -keysize -keystore keysto ...

  10. PythonI/O进阶学习笔记_1.抽象、面向对象、class/object/type

    前言: 是自己在学习python进阶IO学习视频的时候的理解和笔记,因为很多都是本菜鸟学习时候的自己的理解,有可能理解有误. Content: - 抽象的概念和面向对象的概念?想要大概了解python ...