关于Java的拷贝你能说出个123么？-低调大师

关于Java的拷贝你能说出个123么？

2020-11-27 467

本文内容：讲解对象创建方式及Java中的深拷贝还是浅拷贝。

1、创建对象的5种方式

通过 new 关键字
❝
这是最常用的一种方式，通过 new 关键字调用类的有参或无参构造方法来创建对象。比如 Object obj = new Object();
❞
通过 Class 类的 newInstance() 方法
❝
这种默认是调用类的无参构造方法创建对象。比如 Person p2 = (Person) Class. forName("com.ys.test. Person"). newInstance();
❞
通过 Constructor 类的 newInstance 方法
❝
这和第二种方法类时，都是通过反射来实现。通过 java.lang.relect.Constructor 类的 newInstance() 方法指定某个构造器来创建对象。　　Person p3 = (Person) Person.class.getConstructors()[0].newInstance(); 　　实际上第二种方法利用 Class 的 newInstance() 方法创建对象，其内部调用还是 Constructor 的 newInstance() 方法。
❞
利用 Clone 方法
❝
Clone 是 Object 类中的一个方法，通过对象A.clone() 方法会创建一个内容和对象 A 一模一样的对象 B，clone 克隆，顾名思义就是创建一个一模一样的对象出来。　　Person p4 = (Person) p3.clone();
❞
序列化
❝
序列化是把堆内存中的 Java 对象数据，通过某种方式把对象存储到磁盘文件中或者传递给其他网络节点（在网络上传输）。而反序列化则是把磁盘文件中的对象数据或者把网络节点上的对象数据，恢复成Java对象模型的过程。序列化
❞

Java 基本复制方法

java赋值是复制「对象引用」，如果我们想要得到一个对象的==副本==，使用赋值操作是无法达到目的的：修改新对象的值会同时修改旧对象的值。

public class Client
{
 public static void main(String[] args) throws CloneNotSupportedException
 {
  Person person = new Person(15, "sowhat", new Address("河北", "建华南大街"));
  Person p1 = person;
  p1.setAge(45);
  System.out.println(p1.hashCode());
  System.out.println(person.hashCode());
  System.out.println("================");
  System.out.println(p1.display());
  System.out.println(person.display());
 }
}

Clone 方法

如果创建一个对象的新的副本，也就是说他们的初始状态完全一样，但以后可以「改变各自的状态」，而互不影响，就需要用到java中对象的复制，如原生的clone()方法。本次讲解的是 Java 的深拷贝和浅拷贝，其实现方式正是通过调用 Object 类的 clone() 方法来完成。在 Object.class 类中，源码为:

/**
     * ...
     * performs a "shallow copy" of this object, not a "deep copy" operation.
     * 上面这里已经说明了，clone()方法是浅拷贝，而不是深拷贝
     * @see java.lang.Cloneable
     */
    protected native Object clone() throws CloneNotSupportedException;

这是一个用 native 关键字修饰的方法，关于native关键字有一篇博客专门有介绍，不理解也没关系，只需要知道用 native 修饰的方法就是告诉操作系统，这个方法我不实现了，让操作系统去实现(参考JNI)。具体怎么实现我们不需要了解，只需要知道 clone方法的作用就是「复制对象」，产生一个新的对象。那么这个新的对象和原对象是==什么关系呢==？

基本类型和引用类型

这里再给大家普及一个概念，在 Java 中「基本类型和引用类型」的区别。在 Java 中数据类型可以分为两大类：基本类型和引用类型。基本类型也称为值类型，分别是字符类型 char，布尔类型 boolean以及数值类型 byte、short、int、long、float、double。引用类型则包括类、接口、数组、枚举等。　　Java 将内存空间分为「堆和栈」。基本类型直接在栈 stack中存储数值，而引用类型是将引用放在栈中，实际存储的值是放在堆 heap中，通过栈中的引用指向堆中存放的数据。　　

上图定义的 a 和 b 都是基本类型，其值是「直接存放在栈中」的；而 c 和 d 是 String 声明的，这是一个引用类型，「引用地址是存放在栈中，然后指向堆的内存空间」。　　下面 d = c；这条语句表示将 c 的引用赋值给 d，那么 c 和 d 将指向同一块堆内存空间。

浅拷贝

接下来用代码看看浅拷贝的效果。

package mytest;
@Data//lombok注解
class Person implements Cloneable
{
 private int age;
 private String name;
 private Address address;

 public Person(int age, String name, Address address)
 {
  this.age = age;
  this.name = name;
  this.address = address;
 }

 @Override
 protected Object clone() throws CloneNotSupportedException
 {
  return super.clone();
 }

 public String display()
 {
  return "Person [age=" + age + ", name=" + name + ", address=" + address + "]";
 }
}

@Data//lombok注解
class Address
{
 private String province;
 private String street;

 public Address(String province, String street)
 {
  this.province = province;
  this.street = street;
 }
 @Override
 public String toString()
 {
  return "Address [province=" + province + ", street=" + street + "]";
 }
}

public class Client
{
 public static void main(String[] args) throws CloneNotSupportedException
 {
  Person person = new Person(15, "sowhat", new Address("河北", "建华南大街"));
  Person clonePerson = (Person) person.clone();
  System.out.println(person);
  System.out.println(clonePerson);

  // 信息完全一样
  System.out.println(person.display());
  System.out.println(clonePerson.display());
  System.out.println("信息完全一致");

  System.out.println("原始年龄:" + person.getAge());
  System.out.println("克隆后原始年龄:" + clonePerson.getAge());
  System.out.println("年龄完全一样");

  System.out.println("原始名字哈希值:" + person.getName().hashCode());
  System.out.println("克隆后名字哈希值:" + clonePerson.getName().hashCode());
  System.out.println("字符串哈希值完全一样");

  clonePerson.setName("xiaomai");
  clonePerson.setAge(20);
  clonePerson.getAddress().setStreet("中山路");
  System.out.println(clonePerson.display());
  System.out.println(person.display());
  System.out.println("年龄跟姓名 是完全的深拷贝 副本跟原值无关的！");
  System.out.println("地址信息的修改是浅拷贝  ");

 }
}

结果如下：

❝
mytest.Person@15f550a

mytest.Person@6b2d4a

Person [age=15, name=sowhat, address=Address [province=河北, street=建华南大街]]

Person [age=15, name=sowhat, address=Address [province=河北, street=建华南大街]]

信息完全一致

原始年龄:15

克隆后原始年龄:15

年龄完全一样

原始名字哈希值:-1432601412

克隆后名字哈希值:-1432601412

字符串哈希值完全一样

Person [age=20, name=xiaomai, address=Address [province=河北, street=中山路]]

Person [age=15, name=sowhat, address=Address [province=河北, street=中山路]]
❞

结论：

原对象与新对象是两个不同的对象。
拷贝出来的新对象与原对象内容一致
接着将新对象里面的信息进行了修改，然后输出发现原对象里面的部分信息也跟着变了。其中基本类型跟 String类型的改变不会影响到原始对象的改变。而其他的Ojbect 类型改变的时候会影响到原始数据。上面的结论称为浅拷贝 「浅拷贝」：创建一个新对象，然后将当前对象的非静态字段复制到该对象，如果字段类型是值类型（基本类型跟String）的，那么对该字段进行 「复制」；如果字段是引用类型的， 「则只复制该字段的引用而不复制引用指向的对象(也就是只复制对象的地址)」。此时新对象里面的引用类型字段相当于是原始对象里面引用类型字段的一个副本，原始对象与新对象里面的引用字段 指向的是同一个对象。因此，修改clonePerson里面的address内容时，原person里面的address内容会跟着改变。

深拷贝

了解了浅拷贝，那么深拷贝是什么也就很清楚了。那么该如何实现深拷贝呢？Object 类提供的 clone 是只能实现浅拷贝的。，即将「引用类型的属性内容也拷贝一份新的」。那么，实现深拷贝我这里收集到两种方式：「第一种」是给需要拷贝的引用类型也实现Cloneable接口并覆写clone方法；「第二种」则是利用序列化。接下来分别对两种方式进行演示。

深拷贝-clone方式

对于以上演示代码，利用clone方式进行深拷贝无非就是将Address类也实现Cloneable，然后对Person的clone方法进行调整。让每个引用类型属性内部都重写clone() 方法,既然引用类型不能实现深拷贝，那么我们将每个引用类型都拆分为基本类型，分别进行浅拷贝。比如上面的例子，Person 类有一个引用类型 Address(其实String 也是引用类型，但是String类型有点特殊，后面会详细讲解)，我们在 Address 类内部也重写 clone 方法。如下：

package mytest;
@Data//lombok注解
class Person implements Cloneable
{
 private int age;
 private String name;
 private Address address;
 protected int abc = 12;

 public Person(int age, String name, Address address)
 {
  this.age = age;
  this.name = name;
  this.address = address;
 }
 
 @Override  // clone 重载
 protected Object clone() throws CloneNotSupportedException
 {
  Person person = (Person) super.clone();
  //手动对address属性进行clone，并赋值给新的person对象
  person.address = (Address) address.clone();
  return person;
 }

 public String display()
 {
  return "Person [age=" + age + ", name=" + name + ", address=" + address + "]";
 }
}

@Data//lombok注解
class Address implements  Cloneable
{
 private String province;
 private String street;

 public Address(String province, String street)
 {
  this.province = province;
  this.street = street;
 }
 // 深拷贝时添加
 @Override
 protected Object clone() throws CloneNotSupportedException
 {
  return super.clone();
 }
 
 @Override
 public String toString()
 {
  return "Address [province=" + province + ", street=" + street + "]";
 }
}

public class Client
{
 public static void main(String[] args) throws CloneNotSupportedException
 {
  Person person = new Person(15, "sowhat", new Address("河北", "建华南大街"));
  Person p1 = person;
  p1.setAge(45);
  System.out.println(p1.hashCode());
  System.out.println(person.hashCode());

  System.out.println(p1.display());
  System.out.println(person.display());
  System.out.println("-----------");

  Person clonePerson = (Person) person.clone();
  System.out.println(person);
  System.out.println(clonePerson);

  // 信息完全一样
  System.out.println(person.display());
  System.out.println(clonePerson.display());
  System.out.println("信息完全一致");

  System.out.println("原始年龄:" + person.getAge());
  System.out.println("克隆后原始年龄:" + clonePerson.getAge());
  System.out.println("年龄完全一样");

  System.out.println("原始名字哈希值:" + person.getName().hashCode());
  System.out.println("克隆后名字哈希值:" + clonePerson.getName().hashCode());
  System.out.println("字符串哈希值完全一样");

  clonePerson.setName("sowhat1412");
  clonePerson.setAge(20);
  clonePerson.getAddress().setStreet("中山路");
  System.out.println(clonePerson.display());
  System.out.println(person.display());
  System.out.println("年龄跟姓名 是完全的深拷贝 副本跟原值无关的！");
  System.out.println("地址信息的修改是浅拷贝  ");

 }
}

但是这种做法有个弊端，这里我们Person 类只有一个 Address 引用类型，而 Address 类没有，所以我们只用重写 Address 类的clone 方法，但是如果 Address 类也存在一个引用类型，那么我们也要重写其clone 方法，这样下去，有多少个引用类型，我们就要重写多少次，如果存在很多引用类型，那么代码量显然会很大，所以这种方法不太合适。

利用序列化

序列化是将对象写到流中便于传输，而反序列化则是把对象从流中读取出来。这里写到流中的对象则是原始对象的一个拷贝，因为原始对象还存在 JVM 中，所以我们可以利用对象的序列化产生克隆对象，然后通过反序列化获取这个对象。注意每个需要序列化的类都要实现 Serializable 接口，如果有某个属性不需要序列化，可以将其声明为 transient，即将其排除在克隆属性之外。

package mytest;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * 利用序列化和反序列化进行对象的深拷贝
 * @author  ljj
 */
class DeepClone implements Serializable
{
 private static final long serialVersionUID = 1412L;
 
 public Object deepClone() throws Exception
 {
  //序列化
  ByteArrayOutputStream bos = new ByteArrayOutputStream();
  ObjectOutputStream oos = new ObjectOutputStream(bos);
  oos.writeObject(this);
  //反序列化
  ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
  ObjectInputStream ois = new ObjectInputStream(bis);
  return ois.readObject();
 }
}
@Data
class Person extends DeepClone
{
 private static final long serialVersionUID = 1L;
 private int age;
 private String name;
 private Address address;

 public Person(int age, String name, Address address)
 {
  this.age = age;
  this.name = name;
  this.address = address;
 }

 public String display()
 {
  return "Person [age=" + age + ", name=" + name + ", address=" + address + "]";
 }
}

@Data
class Address extends DeepClone
{
 private static final long serialVersionUID = 1412L;
 private String province;
 private String street;

 public Address(String province, String street)
 {
  this.province = province;
  this.street = street;
 }

 @Override
 public String toString()
 {
  return "Address [province=" + province + ", street=" + street + "]";
 }

 public void setStreet(String street)
 {
  this.street = street;
 }
}

public class Client
{
 public static void main(String[] args) throws Exception
 {
  Person person = new Person(15, "sowhat", new Address("河北", "建华南大街"));

  Person clonePerson = (Person) person.deepClone();

  System.out.println(person);
  System.out.println(clonePerson);

  System.out.println(person.display());
  System.out.println(clonePerson.display());

  clonePerson.setName("sowhat1412");
  clonePerson.setAge(20);
  Address address = clonePerson.getAddress();
  address.setStreet("中山路");
  System.out.println(clonePerson.display());
  System.out.println(person.display());

 }
}

本文分享自微信公众号 - sowhat1412（sowhat9094）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

微信关注我们

原文链接：https://my.oschina.net/u/4511602/blog/4754999

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

一文彻底吃透 JavaScript 的执行机制

执行 & 运行首先我们需要声明下，JavaScript的执行和运行是两个不同概念的，执行，一般依赖于环境，比如node、浏览器、Ringo等，JavaScript 在不同环境下的执行机制可能并不相同。而今天我们要讨论的Event Loop就是JavaScript的一种执行方式。所以下文我们还会梳理node的执行方式。而运行呢，是指JavaScript 的解析引擎。这是统一的。关于 JavaScript 此篇文章中，这个小标题下，我们只需要牢记一句话:JavaScript 是单线程语言，无论HTML5里面Web-Worker还是 node 里面的cluster都是“纸老虎”，而且cluster还是进程管理相关。这里读者注意区分：进程和线程。既然JavaScript是单线程语言，那么就会存在一个问题，所有的代码都得一句一句的来执行。就像我们在食堂排队打饭，必须一个一个排队点菜结账。那些没有排到的，就得等着~ 概念梳理在详解执行机制之前，先梳理一下JavaScript的一些基本概念，方便后面我们说到的时候大伙儿心里有个印象和大概的轮廓。事件循环(Event Loop) 什么...

2020-11-27

411

项目背景这是给某数据中心做的一个项目，项目难度之大令人发指，这个项目真正的让我感觉到了，商场如战场，而我只是其中的一个小兵，太多的战术，太多的高层之间的较量，太多的内幕了。具体这个项目的情况，我有空再写相关的博文出来。这个项目是要求做环境监控，我们暂且把受监控的设备称为采集设备，采集设备的属性称为监控指标。项目要求：系统支持不少于10w个监控指标，每个监控指标的数据更新不大于20秒，存储延迟不超过120秒。那么，我们可以通过简单的计算得出较理想的状态——要存储的数据为：每分钟30w，每个小时1800w，也就是每天4亿3千两百万。而实际，数据量会比这个大5%左右。（实际上大部分是信息垃圾，可以通过数据压缩进行处理的，但是别人就是要搞你，能咋办）上面是项目要求的指标，我想很多有不少大数据处理经验的同学都会呲之以鼻，就这么点？嗯，我也看了很多大数据处理的东西，但是之前没处理过，看别人是头头是道，什么分布式，什么读写分离，看起来确实很容易解决。但是，问题没这么简单，上面我说了，这是一个非常恶劣的项目，是一个行业恶性竞争典型的项目。没有更多的服务器，而是这个服务器除了搭配数据库、集中采集...

2020-11-27

435

资源下载

更多资源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。