深拷贝和浅拷贝解析

1.浅拷贝（需要实现Cloneable 接口）

public class ShallowClone implements Cloneable {
private String name;
private int age;
private List<String> books;

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

public List<String> getBooks() {
    return books;
}

public void setBooks(List<String> books) {
    this.books = books;
}

@Override
public String toString() {
    return "ShallowClone{" +
            "name='" + name + '\'' +
            ", age=" + age +
            ", books=" + books +
            '}';
}

public ShallowClone clone() {
    ShallowClone clone = null;
    try {
        clone = (ShallowClone) super.clone();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return clone;
}

public ShallowClone deepClone() {
    ShallowClone clone = new ShallowClone();
    clone.name = this.name;
    clone.age = this.age;
    if(this.books != null){
        clone.books = new ArrayList<>(this.books);
    }
    return clone;
}

}

public class MyTest {
public static void main(String[] args) {
    ShallowClone shallowClone = new ShallowClone();
    shallowClone.setName("SourceName");
    shallowClone.setAge(28);
    ArrayList<String> list = new ArrayList<>();
    list.add("java");
    list.add("c++");
    shallowClone.setBooks(list);

    ShallowClone cloneObj = shallowClone.clone();

    //判断两个对象是否执行同一个引用地址
    //System.out.println(shallowClone == cloneObj);

    //修改一个对象的内容是否会影响到另一个对象
    shallowClone.setName("newName");
    shallowClone.setAge(20);
    shallowClone.getBooks().add("JavaScript");

    System.out.println("shallowClone:"+shallowClone.toString()+
            "\ncloneObj"+cloneObj.toString());

    shallowClone.setBooks(Arrays.asList("hello"));
    System.out.println("shallowClone:"+shallowClone.toString()+
            "\ncloneObj"+cloneObj.toString());
}

执行结果：

结果分析：
1.我们发现对象被clone后，克隆后的对象拥有了原对象的成员值，但是两个对象地址值是不一样的
2.原对象的成员值改变后，我们发现基本数据类型的成员值没有发生变化，引用类型的成员只是拷贝了引用地址过去（两个成员值指向同一个内存地址）

浅拷贝的简单理解：
创建一个新的对象，新对象的每个值都是由原对象的值通过 = 进行赋值的（基本数据类型是复制值，引用数据类型是复制引用地址）

2.深拷贝
创建一个全新的对象，新的对象内部所有的成员也都是新的，只是初始化的值已经由被拷贝的对象确定了

public ShallowClone deepClone() {
    ShallowClone clone = new ShallowClone();
    clone.name = this.name;
    clone.age = this.age;
    if(this.books != null){
        clone.books = new ArrayList<>(this.books);
    }
    return clone;
}

从代码中我们可以发现，克隆后的对象的成员值是根据原对象的成员值来确定的，其他没有任何关联

对象拷贝工具：
浅拷贝可以通过实现Clonebale接口来完成，深拷贝需要自己来实现

Apache的两个版本：（反射机制）

org.apache.commons.beanutils.PropertyUtils.copyProperties(Object dest, Object orig)
org.apache.commons.beanutils.BeanUtils#cloneBean

Spring版本：（反射机制）
org.springframework.beans.BeanUtils.copyProperties(Object source, Object target, Class editable, String[] ignoreProperties)

cglib版本：（使用动态代理，效率高）
net.sf.cglib.beans.BeanCopier.copy(Object paramObject1, Object paramObject2, Converter paramConverter)

更多内容参考：https://blog.csdn.net/liuyueyi25/article/details/78837722