前言

java中得复制，到底有哪些？ 浅拷贝和深拷贝，有什么区别呢？ 我们平时习惯属性间得复制，beanUtils.copyproperties，属于哪种类型得复制？ 我们常用得数组间得复制转换，又分为哪些？ 再IO中，零拷贝又是什么意思？

复制有哪些类型？

将一个对象的引用复制给另外一个对象，一共有三种方式。
第一种方式是直接赋值，
第二种方式 是浅拷贝，
第三种是深拷贝。

浅拷贝

对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝

如何实现浅拷贝？

类实现implements Cloneable接口，然后重写clone方法

  1. package com.haoker.copy;
  3. /**
  4.  * @ClassName SimpleCopy
  5.  * @Description TODO
  6.  * @Author 豪
  7.  * @Date 2021/8/3 23:44
  8.  * @Version I. 0
  9.  **/
  10. public class SimpleCopy {
  11.     public static void main(String[] args) throws CloneNotSupportedException {
  12.         PersonDest2 personDest2 = new PersonDest2(1, "12345", 21);
  13.         Person p = new Person(23, "zhang",personDest2);
  14.         Person p1 = (Person) p.clone();
  15.         System.out.println(p.getPersonDest2());
  16.         System.out.println(p1.getPersonDest2());
  17.     }
  18. }
  19. class Person implements Cloneable{
  21.     //private Integer age;
  22.     private int age;//阿里规范中规定pojo类中的属性强制使用包装类型，这里只是测试
  23.     private String name;
  24.     private PersonDest2 personDest2;
  26.     public Person(Integer age, String name,PersonDest2 personDest2) {
  27.         super();
  28.         this.age = age;
  29.         this.name = name;
  30.         this.personDest2 = personDest2;
  31.     }
  33.     public Integer getAge() {
  34.         return age;
  35.     }
  37.     public void setAge(Integer age) {
  38.         this.age = age;
  39.     }
  41.     public String getName() {
  42.         return name;
  43.     }
  45.     public void setName(String name) {
  46.         this.name = name;
  47.     }
  49.     public PersonDest2 getPersonDest2() {
  50.         return personDest2;
  51.     }
  53.     public void setPersonDest2(PersonDest2 personDest2) {
  54.         this.personDest2 = personDest2;
  55.     }
  57.     @Override
  58.     public String toString() {
  59.         return super.toString();
  60.     }
  62.     @Override
  63.     protected Object clone() throws CloneNotSupportedException {
  64.         return super.clone();
  65.     }
  66. }

深拷贝

对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。

如何实现深拷贝？

1、与通过重写clone方法实现浅拷贝的基本思路一样，只需要为对象图的每一层的每一个对象都实现Cloneable接口并重写clone方法，最后在最顶层的类的重写的clone方法中调用所有的clone方法即可实现深拷贝。简单的说就是：每一层的每个对象都进行浅拷贝=深拷贝。

  1. import java.io.ByteArrayInputStream;
  2. import java.io.ByteArrayOutputStream;
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.io.Serializable;
  8. /* 通过序列化实现深拷贝 */
  9. public class DeepCopyBySerialization {
  10.     public static void main(String[] args) throws IOException, ClassNotFoundException  {
  11.         Age a=new Age(20);
  12.         Student stu1=new Student("摇头耶稣",a,175);
  13.         //通过序列化方法实现深拷贝
  14.         ByteArrayOutputStream bos=new ByteArrayOutputStream();
  15.         ObjectOutputStream oos=new ObjectOutputStream(bos);
  16.         oos.writeObject(stu1);
  17.         oos.flush();
  18.         ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
  19.         Student stu2=(Student)ois.readObject();
  20.         System.out.println(stu1.toString());
  21.         System.out.println(stu2.toString());
  22.         System.out.println();
  23.         //尝试修改stu1中的各属性，观察stu2的属性有没有变化
  24.         stu1.setName("大傻子");
  25.         //改变age这个引用类型的成员变量的值
  26.         a.setAge(99);
  27.         stu1.setLength(216);
  28.         System.out.println(stu1.toString());
  29.         System.out.println(stu2.toString());
  30.     }
  31. }
  33. /*
  34.  * 创建年龄类
  35.  */
  36. class Age implements Serializable{
  37.     //年龄类的成员变量（属性）
  38.     private int age;
  39.     //构造方法
  40.     public Age(int age) {
  41.         this.age=age;
  42.     }
  44.     public int getAge() {
  45.         return age;
  46.     }
  48.     public void setAge(int age) {
  49.         this.age = age;
  50.     }
  52.     public String toString() {
  53.         return this.age+"";
  54.     }
  55. }
  56. /*
  57.  * 创建学生类
  58.  */
  59. class Student implements Serializable{
  60.     //学生类的成员变量（属性）,其中一个属性为类的对象
  61.     private String name;
  62.     private Age aage;
  63.     private int length;
  64.     //构造方法,其中一个参数为另一个类的对象
  65.     public Student(String name,Age a,int length) {
  66.         this.name=name;
  67.         this.aage=a;
  68.         this.length=length;
  69.     }
  70.     //eclipe中alt+shift+s自动添加所有的set和get方法
  71.     public String getName() {
  72.         return name;
  73.     }
  75.     public void setName(String name) {
  76.         this.name = name;
  77.     }
  79.     public Age getaAge() {
  80.         return this.aage;
  81.     }
  83.     public void setaAge(Age age) {
  84.         this.aage=age;
  85.     }
  87.     public int getLength() {
  88.         return this.length;
  89.     }
  91.     public void setLength(int length) {
  92.         this.length=length;
  93.     }
  94.     //设置输出的字符串形式
  95.     public String toString() {
  96.         return "姓名是： "+this.getName()+"， 年龄为： "+this.getaAge().toString()+", 长度是： "+this.getLength();
  97.     }
  98. }

2、使用序列化。可以先使对象实现 Serializable 接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里，再从流里读出来，便可以重建对象

  1.     /**
  2.      * 使用java的序列化实现深层复制
  3.      */
  4.     @SuppressWarnings("unchecked")
  5.     public static <T extends Serializable> T deepClone(T a){
  6.         T t = null;
  7.         if(a != null){
  8.             try{
  9.                 ByteArrayOutputStream baos = new ByteArrayOutputStream();
  10.                 ObjectOutputStream oos = new ObjectOutputStream(baos);
  11.                 oos.writeObject(a);
  12.                 oos.flush();
  13.                 oos.close();
  14.                 byte[] arrByte = baos.toByteArray();
  15.                 ByteArrayInputStream bais = new ByteArrayInputStream(arrByte);
  16.                 ObjectInputStream ois = new ObjectInputStream(bais);
  17.                 t = (T)ois.readObject();
  18.                 ois.close();
  19.             }catch(Exception e){
  20.             }
  21.         }
  22.         return t;
  23.     }

数组间得复制，常用得哪几种？

1、利用for循环依次检索

  1. package com.haoker.ArraysCopy;
  3. /**
  4.  * 功能描述:通过循环赋值
  5.  * @author: 豪
  6.  * @date: 2021/8/3 23:59
  7.  **/
  8. public class Arrays {
  9.     public static void main(String[] args) {
  10.         int[] arrays1 = {3,4,6,8,9};
  11.         int[] ret = copyArray(arrays1);
  12.         System.out.println("拷贝后：");
  13.         for (int x:ret) {
  14.             System.out.print(" "+x+" ");
  15.         }
  16.     }
  17.     public static int[] copyArray(int[]a){
  18.         int[] ret = new int[a.length];
  19.         for(int i = 0; i<ret.length; i++){
  20.             ret[i]=a[i];
  21.         }//利用for循环
  22.         return ret;//返回数组
  23.     }
  24. }

2、利用System.arraycopy()方法

  1. package com.haoker.ArraysCopy;
  3. /**
  4.  * 功能描述:利用System.arraycopy()方法
  5.  * @author: 豪
  6.  * @date: 2021/8/3 23:59
  7.  **/
  8. public class SystemArraycopy {
  9.     public static void main(String[] args) {
  10.         int[] arrays1 = {3,4,6,8,9};
  11.         int[] ret = copyArray(arrays1);
  12.         System.out.println("拷贝后：");
  13.         for (int x:ret) {
  14.             System.out.print(" "+x+" ");
  15.         }
  16.     }
  17.     public static int[] copyArray(int[]a){
  18.         int[] ret = new int[a.length];
  19.         //参数一：被拷贝得源数组
  20.         //参数二：被拷贝得源数组下标开始得位置
  21.         //参数三：目标数组
  22.         //参数四：目标数组下标开始得位置
  23.         //参数五：复制多少长度
  24.         System.arraycopy( a,1,ret,0,ret.length-1);
  25.         return ret;
  26.     }
  27. }

3、利用Arrays.copyof()方法，底层还是System.arraycopy方法

  1. package com.haoker.ArraysCopy;
  3. import java.util.Arrays;
  5. /**
  6.  * 功能描述:利用Arrays.copyof()方法
  7.  * @author: 豪
  8.  * @date: 2021/8/3 23:59
  9.  **/
  10. public class ArraysCopyof {
  11.     public static void main(String[] args) {
  12.         int[] arrays1 = {3,4,6,8,9};
  13.         System.out.println("拷贝后：");
  14.         copyArray(arrays1);
  15.     }
  16.     public static void copyArray(int[]a){
  17.         int[] ret =Arrays.copyOf(a, a.length-1);
  18.         for (int x:ret) {
  19.             System.out.print(" "+x+" ");
  20.         }
  21.     }
  22. }

4、通过clone()

  1. package com.haoker.ArraysCopy;
  3. import java.util.Arrays;
  5. /**
  6.  * 功能描述:通过clone()方法
  7.  * @author: 豪
  8.  * @date: 2021/8/3 23:59
  9.  **/
  10. public class ArraysClone {
  11.     public static void main(String[] args) {
  12.         int[] arrays1 = {3,4,6,8,9};
  13.         System.out.println("拷贝后：");
  14.         copyArray(arrays1);
  15.     }
  16.     public static void copyArray(int[]a){
  17.         int[] ret =a.clone();
  18.         for (int x:ret) {
  19.             System.out.print(" "+x+" ");
  20.         }
  21.     }
  22. }

常用属性间得复制，beanUtils.copyproperties，属于哪种类型复制？

浅拷贝，因为复制对象得时候，源对象进行改变后，复制过来得值也会跟着变
image.png

  1. package com.haoker.copy;
  2. import org.springframework.beans.BeanUtils;
  3. /**
  4.  * @ClassName Copy
  5.  * @Description TODO
  6.  * @Author 豪
  7.  * @Date 2021/8/3 23:17
  8.  * @Version I. 0
  9.  **/
  10. public class Copy {
  12.     public static void main(String[] args){
  13.         //测试是否是浅拷贝
  14.         PersonDest2 personDest2 = new PersonDest2(1, "12345", 21);
  15.         PersonSource personSource = new PersonSource(1, "pjmike", "12345", 21,personDest2);
  16.         PersonDest personDest = new PersonDest();
  17.         BeanUtils.copyProperties(personSource,personDest);
  18.         System.out.println("persondest: "+personDest);
  19.         personDest2.setUsername("xiugai");
  20.         System.out.println("persondest: "+personDest);
  21.         System.out.println("personSource: "+personSource);
  22.     }
  23. }
  25. class PersonDest {
  26.     private Integer id;
  27.     private String username;
  28.     private Integer age;
  29.     private PersonDest2 personDest2;
  30.     // getters/setters omiited
  32.     public PersonDest() {
  33.     }
  35.     public PersonDest(Integer id, String username, Integer age) {
  36.         this.id = id;
  37.         this.username = username;
  38.         this.age = age;
  39.     }
  41.     public Integer getId() {
  42.         return id;
  43.     }
  45.     public void setId(Integer id) {
  46.         this.id = id;
  47.     }
  49.     public String getUsername() {
  50.         return username;
  51.     }
  53.     public void setUsername(String username) {
  54.         this.username = username;
  55.     }
  57.     public Integer getAge() {
  58.         return age;
  59.     }
  61.     public void setAge(Integer age) {
  62.         this.age = age;
  63.     }
  65.     public PersonDest2 getPersonDest2() {
  66.         return personDest2;
  67.     }
  69.     public void setPersonDest2(PersonDest2 personDest2) {
  70.         this.personDest2 = personDest2;
  71.     }
  73.     @Override
  74.     public String toString() {
  75.         return "PersonDest{" +
  76.                 "id=" + id +
  77.                 ", username='" + username + '\'' +
  78.                 ", age=" + age +
  79.                 ", personDest2=" + personDest2 +
  80.                 '}';
  81.     }
  82. }
  84. class PersonDest2 {
  85.     private Integer id;
  86.     private String username;
  87.     private Integer age;
  88.     // getters/setters omiited
  90.     public PersonDest2() {
  91.     }
  93.     public PersonDest2(Integer id, String username, Integer age) {
  94.         this.id = id;
  95.         this.username = username;
  96.         this.age = age;
  97.     }
  99.     public Integer getId() {
  100.         return id;
  101.     }
  103.     public void setId(Integer id) {
  104.         this.id = id;
  105.     }
  107.     public String getUsername() {
  108.         return username;
  109.     }
  111.     public void setUsername(String username) {
  112.         this.username = username;
  113.     }
  115.     public Integer getAge() {
  116.         return age;
  117.     }
  119.     public void setAge(Integer age) {
  120.         this.age = age;
  121.     }
  123.     @Override
  124.     public String toString() {
  125.         return "PersonDest{" +
  126.                 "id=" + id +
  127.                 ", username='" + username + '\'' +
  128.                 ", age=" + age +
  129.                 '}';
  130.     }
  131. }
  133. class PersonSource  {
  134.     private Integer id;
  135.     private String username;
  136.     private String password;
  137.     private Integer age;
  138.     private PersonDest2 personDest2;
  140.     public PersonSource() {
  141.     }
  143.     public PersonSource(Integer id, String username, String password, Integer age,PersonDest2 personDest2) {
  144.         this.id = id;
  145.         this.username = username;
  146.         this.password = password;
  147.         this.age = age;
  148.         this.personDest2 = personDest2;
  149.     }
  151.     public Integer getId() {
  152.         return id;
  153.     }
  155.     public void setId(Integer id) {
  156.         this.id = id;
  157.     }
  159.     public String getUsername() {
  160.         return username;
  161.     }
  163.     public void setUsername(String username) {
  164.         this.username = username;
  165.     }
  167.     public String getPassword() {
  168.         return password;
  169.     }
  171.     public void setPassword(String password) {
  172.         this.password = password;
  173.     }
  175.     public Integer getAge() {
  176.         return age;
  177.     }
  179.     public void setAge(Integer age) {
  180.         this.age = age;
  181.     }
  183.     public PersonDest2 getPersonDest2() {
  184.         return personDest2;
  185.     }
  187.     public void setPersonDest2(PersonDest2 personDest2) {
  188.         this.personDest2 = personDest2;
  189.     }
  191.     @Override
  192.     public String toString() {
  193.         return "PersonSource{" +
  194.                 "id=" + id +
  195.                 ", username='" + username + '\'' +
  196.                 ", password='" + password + '\'' +
  197.                 ", age=" + age +
  198.                 ", personDest2=" + personDest2 +
  199.                 '}';
  200.     }
  201. }

零拷贝详解