前言
在Java中关于对象的拷贝我们大致可以分为两种，一种是浅拷贝（也叫引用拷贝），另外一种是深拷贝（也称值拷贝）。
示例
我相信绝大多数程序员Ctrl+C、Ctrl+V都玩的很溜，我也一样哈。工作周报我觉得大家在熟悉不过了吧。以我自身写周报为例子，为了节省自己的时间（主要还是自己懒），我基本都是Ctrl+C、Ctrl+V别人写好的周报格式进行现改。一人一份工作周报，总不能有两个人的周报一字不差、一模一样的吧。或多或少还是有点出入的，比如改下标题，发件人，工作内容等等。
浅拷贝
定义：被复制的对象所有的变量都含有与原来对象相同的值，所有的对其他对象的引用都仍然指向原来的对象（即原始的对象和其副本引用同一个对象）。
先来看下程序代码
/**
* 工作周报类
* @author zhh
* @date 2017-08-23 上午11:03:47
*/
class Report implements Cloneable {
private String title; // 标题
private String sender; // 发送者
private String receiver; // 接收者
private ArrayList<String> content; //内容
public Report(String title, String sender, String receiver) {
this.title = title;
this.sender = sender;
this.receiver = receiver;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getSender() {
return sender;
}
public void setSender(String sender) {
this.sender = sender;
}
public String getReceiver() {
return receiver;
}
public void setReceiver(String receiver) {
this.receiver = receiver;
}
public ArrayList<String> getContent() {
return content;
}
public void setContent(ArrayList<String> content) {
this.content = content;
}
public void print() {
System.out.println(this);
}
@Override
public Report clone() {
Report msg = null;
try {
msg = (Report) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return msg;
}
@Override
public String toString() {
return "Report [title=" + title + ", sender=" + sender + ", receiver=" + receiver + ", content=" + content
+ "]";
}
}举个例子，我这里拷贝下公司UI小姐姐的周报模板现改现卖，像标题，发送者，内容什么的大致还是得改改。写个主方法测试下。
public static void main(String[] args) {
Report report = new Report("yg工作周报", "yg", "boss");
ArrayList<String> content = new ArrayList<>();
content.add("1.参加研讨会议, 确定需求");
content.add("2.设计首页的icon以及界面");
report.setContent(content);
Report report1 = report.clone();
report1.setTitle("zhh工作周报");
report1.setSender("zhh");
ArrayList<String> content1 = report1.getContent();
content1.set(1, "2.搭建基础的后台框架");
report1.setContent(content1);
System.out.println("----------UI小姐姐工作周报--------------");
report.print();
System.out.println("----------我的工作周报--------------");
report1.print();
}程序运行的结果如下:
----------UI小姐姐工作周报--------------
Report [title=yg工作周报, sender=yg, receiver=boss, content=[1.参加研讨会议, 确定需求, 2.搭建基础的后台框架]]
----------我的工作周报--------------
Report [title=zhh工作周报, sender=zhh, receiver=boss, content=[1.参加研讨会议, 确定需求, 2.搭建基础的后台框架]]虽然执行没有发生什么异常，但其结果显然是不对的。UI小姐姐跟我干的活一样啦？老板看了显然也是一脸懵逼的。搞不好我也就被UI小姐姐给顶替掉了（开个玩笑哈）。
但为什么会这样呢？克隆以后为什么我的工作内容把UI的工作内容替换了呢？而其他标题、发送者却没有这种情况。
我们知道在Java当中Object类是所有类的顶级父类，而其clone方法只会拷贝对象中的基本数据类型，对于数组、容器对象、引用对象等都不会拷贝。程序Report类自写的clone方法中 msg = (Report) super.clone(); 就是调用了Object类的clone方法。String类虽然也是引用类型，但由于其的特殊性（final 类），虽然复制的引用，但是修改值的时候并没有改变被复制对象的值；而ArrayList复制的仅仅是引用，导致原本引用和副本引用指向同一对象，所以上述代码修改任意一个对象的content都会影响另外一个。
深拷贝
根据上面的分析，浅拷贝是无法去完成含有除基本数据类型之外对象的拷贝的。
定义：被复制的对象所有的变量都含有与原来对象相同的值，所有的对其他对象的引用也都指向复制过的新的对象（即原始的对象和其副本引用不同对象）。
这里我们自己实现深拷贝，让原始对象和其副本对象指向不同对象。
其实代码和浅拷贝大致相同，差别只是在Report类重写的clone方法，这里我就单独拿出来写下了。
...
@Override
public Report clone() {
Report msg = null;
try {
msg = (Report) super.clone();
// 将引用对象 content 也 clone下
msg.content = (ArrayList<String>) this.content.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return msg;
}
...测试的主方法同浅拷贝，不做修改直接运行，运行的结果如下：
----------UI小姐姐工作周报--------------
Report [title=yg工作周报, sender=yg, receiver=boss, content=[1.参加研讨会议, 确定需求, 2.设计首页的icon以及界面]]
----------我的工作周报--------------
Report [title=zhh工作周报, sender=zhh, receiver=boss, content=[1.参加研讨会议, 确定需求, 2.搭建基础的后台框架]]这里你可以看到，拷贝后两者的内容之间并没有相互的影响。
扩展
深拷贝除了上述实现方式外，也可以用序列化来实现。
/**
* 序列化实现深拷贝
* @author zhh
* @date 2017-08-23 下午1:04:44
*/
class Report implements Serializable {
private static final long serialVersionUID = -760030405417987698L;
private String title; // 标题
private String sender; // 发送者
private String receiver; // 接收者
private ArrayList<String> content; //内容
public Report(String title, String sender, String receiver) {
this.title = title;
this.sender = sender;
this.receiver = receiver;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getSender() {
return sender;
}
public void setSender(String sender) {
this.sender = sender;
}
public String getReceiver() {
return receiver;
}
public void setReceiver(String receiver) {
this.receiver = receiver;
}
public ArrayList<String> getContent() {
return content;
}
public void setContent(ArrayList<String> content) {
this.content = content;
}
public void print() {
System.out.println(this);
}
@Override
public Report clone() {
ByteArrayOutputStream bos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bis = null;
ObjectInputStream ois = null;
try {
// 1.将对象序列化成流
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
oos.writeObject(this);
// 2.将流序列化成对象
bis = new ByteArrayInputStream(bos.toByteArray());;
ois = new ObjectInputStream(bis);
return (Report) ois.readObject();
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
@Override
public String toString() {
return "Report [title=" + title + ", sender=" + sender + ", receiver=" + receiver + ", content=" + content
+ "]";
}
}测试的主方法同浅拷贝，不做修改直接运行，运行的结果如下：
----------UI小姐姐工作周报--------------
Report [title=yg工作周报, sender=yg, receiver=boss, content=[1.参加研讨会议, 确定需求, 2.设计首页的icon以及界面]]
----------我的工作周报--------------
Report [title=zhh工作周报, sender=zhh, receiver=boss, content=[1.参加研讨会议, 确定需求, 2.搭建基础的后台框架]]
事实证明，用序列化来实现对象的深拷贝也是可行的。主要原因是在对象序列化流的过程当中，写在流里面的是对象的一个拷贝，而原本的对象仍然存在堆内。
序列化实现深拷贝过程中，我们实现了Serializable这个空接口，来标明Report类可序列化。
这里要说一下 为什么要给 serialVersionUID 赋值
举个例子，当对象序列化存到硬盘上后，比方我修改了这个对象的属性，那么在反序列化的过程就会出现异常。
一旦我们给 serialVersionUID 赋值，当序列化和反序列化的 serialVersionUID 相同的时候，中间过程修改对象属性就不会像上面抛出异常，而是以属性的对应类型赋默认值（如String类型默认为null，int类型默认为0等等）
java
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。