Java中的对象拷贝(Object Copy)指的是将一个对象的所有属性（成员变量）拷贝到另一个有着相同类类型的对象中去。

举一个例子就是：

class Person {
  private String name;
  private int age;
  private Address addr;
	
  //setter,getter
}
class Address{
  private String country;
  private String city;
  private String street;
	
  //setter,getter
}

main(String[] args){
  Person a=new Persion();
  a.setName("Tomy");
  a.setAge(16);
  Address a_addr=new Address();
  a_addr.setCountry("中国");
  a_addr.setCity("成都");
  a_addr.setStreet("天府大道");
  a.setAddr(a_addr);
	
  //clone
  Person b=new Persion();
  b.setName(a.getName())
  b.setAge(a.getAge());
  b.setAddr(a.getAddr());
}

浅拷贝

对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。因为是两份不同的数据，所以对其中一个对象的该成员变量值进行修改，不会影响另一个对象拷贝得到的数据。
对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。

继续以上面的例子举例：

main(String[] args){
  Person a=new Persion();
  a.setName("Tomy");
  a.setAge(16);
  Address a_addr=new Address();
  a_addr.setCountry("中国");
  a_addr.setCity("成都");
  a_addr.setStreet("天府大道");
  a.setAddr(a_addr);
	
  //clone
  Person b=new Persion();
  b.setName(a.getName());
  b.setAge(a.getAge());
  b.setAddr(a.getAddr());
	
  a.setName("Jerry");
  a.setAge(12);
  a_addr.setCountry("中国");
  a_addr.setCity("北京");
  a_addr.setStreet("东长安街");
	
	System.out.println(b.getName());
	System.out.println(b.getAge());
	System.out.println(b.getAddr().getCity());
	System.out.println(b.getAddr().getStreet());
}

应输出：

Tomy
16
北京
东长安街

实现浅拷贝的方式有两种：

通过构造器实现

class Person {
  // ...field
	public Person(Person person){
	  this.name=person.name;
		this.age=person.age;
		this.addr=person.addr;
	}
}
...
b=new Person(a);

通过实现Cloneable接口,调用Object.clone()方法：

class Person  implements Cloneable {
  // ...field
	
	@Override
  public Object clone() throws CloneNotSupportedException {
    return super.clone();
  }
}
...
b=(Person)a.clone();

深拷贝

对于深拷贝来说，不仅要复制对象的所有基本数据类型的成员变量值，还要为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。

换句话说，即便是修改原对象中的引用数据类型成员变量，也不会影响拷贝后生成的新对象中的引用数据类型成员变量。

继续以上面的例子举例：

  Person a=new Persion();
  a.setName("Tomy");
  a.setAge(16);
  Address a_addr=new Address();
  a_addr.setCountry("中国");
  a_addr.setCity("成都");
  a_addr.setStreet("天府大道");
  a.setAddr(a_addr);
  
  //clone
  Person b=clone(a);
  
  a.setName("Jerry");
  a.setAge(12);
  a_addr.setCountry("中国");
  a_addr.setCity("北京");
  a_addr.setStreet("东长安街");
  
  System.out.println(b.getName());
  System.out.println(b.getAge());
  System.out.println(b.getAddr().getCity());
  System.out.println(b.getAddr().getStreet());

应输出：

Tomy
16
成都
天府大道

实现深拷贝的方式：

在通过重写Object.clone()方法,并实现Cloneable接口，同时为对象所有引用数据类型的成员变量都实现Cloneable接口并重写clone方法，最后在最顶层的类的重写的clone方法中调用所有的clone方法即可实现深拷贝。简单的说就是：每一个引用数据类型的成员变量都进行浅拷贝=深拷贝。

class Person  implements Cloneable {
  // ...field
	
  @Override
  public Object clone() throws CloneNotSupportedException {
    Person obj=(Person) super.clone();
    obj.addr=(Address) obj.addr.clone();
    return obj ;
  }
}
class Address  implements Cloneable {
  // ...field
	
  @Override
  public Object clone() throws CloneNotSupportedException {
    return super.clone();
  }
}
...
b=(Person)a.clone();

使用序列化实现

class Person  implements Cloneable {
  // ...field
}
class Address  implements Cloneable {
  // ...field
}
public final static <T> T clone(T t) {
  try (ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos)) {
    oos.writeObject(t);
		oos.flush();
    try (ByteArrayInputStream bais = new ByteArrayInputStream(bos.toByteArray());ObjectInputStream ois = new ObjectInputStream(bais)){
      T nt = (T) ois.readObject();
      return nt;
    }
  } catch (IOException |ClassNotFoundException e) {
    e.printStackTrace();
  }
  return null;
}
...
b=clone(a);

使用JSON转换实现

String json=toJSON(a);
b=JSON.toObject(json);

咩技术的技术Blog

Java浅拷贝与深拷贝

浅拷贝

深拷贝

GitHub 仓库批量删除