浅拷贝不会创建新的引用，但深拷贝会创建新的引用。

下面是程序解释的深拷贝和浅拷贝。

public class DeepAndShollowCopy {
    int id;
    String name;
    List<String> testlist = new ArrayList<>();

    /*
    // To performing Shallow Copy 
    // Note: Here we are not creating any references. 
      public DeepAndShollowCopy(int id, String name, List<String>testlist)
       { 

       System.out.println("Shallow Copy for Object initialization");
       this.id = id; 
       this.name = name; 
       this.testlist = testlist; 

       }
    */  

    // To performing Deep Copy 
    // Note: Here we are creating one references( Al arraylist object ). 
    public DeepAndShollowCopy(int id, String name, List<String> testlist) {
        System.out.println("Deep Copy for Object initialization");
        this.id = id;
        this.name = name;
        String item;
        List<String> Al = new ArrayList<>();
        Iterator<String> itr = testlist.iterator();
        while (itr.hasNext()) {
            item = itr.next();
            Al.add(item);
        }
        this.testlist = Al;
    }


    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Oracle");
        list.add("C++");
        DeepAndShollowCopy copy=new DeepAndShollowCopy(10,"Testing", list);
        System.out.println(copy.toString());
    }
    @Override
    public String toString() {
        return "DeepAndShollowCopy [id=" + id + ", name=" + name + ", testlist=" + testlist + "]";
    }
}

char * Source = "Hello, world.";

char * ShallowCopy = Source;    

char * DeepCopy = new char(strlen(Source)+1);
strcpy(DeepCopy,Source);        

“ShallowCopy”指向与“Source”相同的内存位置。 “DeepCopy”指向内存中的不同位置，但内容是相同的。

什么是浅复制?

浅复制是对象的逐位复制。创建一个新对象，该对象具有原始对象中值的精确副本。如果对象的任何字段是对其他对象的引用，则只复制引用地址，即只复制内存地址。

In this figure, the MainObject1 has fields field1 of type int, and ContainObject1 of type ContainObject. When you do a shallow copy of MainObject1, MainObject2 is created with field2 containing the copied value of field1 and still pointing to ContainObject1 itself. Note that since field1 is of primitive type, its value is copied to field2 but since ContainedObject1 is an object, MainObject2 still points to ContainObject1. So any changes made to ContainObject1 in MainObject1 will be reflected in MainObject2.

如果这是浅复制，我们看看什么是深复制?

什么是深度复制?

深度复制复制所有字段，并复制由字段指向的动态分配的内存。当对象与其引用的对象一起复制时，就会发生深度复制。

在这个图中，MainObject1具有类型为int的字段field1和类型为ContainObject的字段ContainObject1。在对MainObject1进行深度复制时，MainObject2创建时，field2包含从field1复制的值，而ContainObject2包含从ContainObject1复制的值。注意，MainObject1中对ContainObject1所做的任何更改都不会反映在MainObject2中。

篇好文章

我在这里没有看到一个简短的，容易理解的答案——所以我会试一试。

使用浅拷贝，源指向的任何对象也会被目标指向(因此不会复制引用的对象)。

使用深度复制，源指向的任何对象都将被复制，而目标指向的副本(因此现在每个引用的对象都有2个)。这是递归向下的对象树。

深拷贝

深度复制复制所有字段，并复制由字段指向的动态分配的内存。当对象与其引用的对象一起复制时，就会发生深度复制。

浅拷贝

浅复制是对象的逐位复制。创建一个新对象，该对象具有原始对象中值的精确副本。如果对象的任何字段是对其他对象的引用，则只复制引用地址，即只复制内存地址。

为了便于理解，你可以参考这篇文章: https://www.cs.utexas.edu/~scottm/cs307/handouts/deepCopying.htm

浅拷贝:

深拷贝: