Alibaba interviewer question:

Talk about your understanding of deep cloning and shallow cloning in java

Answer:

(Note: This article is about the difference and implementation method between deep cloning and shallow cloning?)

Talk is cheap

#I have encountered deep and shallow cloning (deep copy, shallow copy) more than once recently Question, except for the impression that there is a clone method, I am confused! ! ! Cloning (copying) is a common operation in Java to quickly obtain a copy of an object. Cloning is divided into deep cloning and shallow cloning.

Shallow clone: ??Create a new object. The properties of the new object are exactly the same as the original object. For non-basic type properties, they still point to the memory address of the object pointed to by the original properties.

Deep cloning: Create a new object, and other objects referenced in the attributes will also be cloned and no longer point to the original object address.

In short, both deep and shallow cloning will allocate a new area in the heap. The difference lies in whether the object referenced by the object attribute needs to be cloned (recursively).

Show you my picture

#pos: the address of the current object;

son: the address pointed to by the son attribute;

name: the name of the object Attributes.

(Related recommendations: java introductory tutorial)

Show you my code

#case1:

public class Son implements Serializable , Cloneable{    private String name;    private Son son;    public Son() {        super();
    }    public String getName() {        return name;
    }    public void setName(String name) {        this.name = name;
    }    public Son getSon() {        return son;
    }    public void setSon(Son son) {        this.son = son;
    }    @Override
    public String toString() {        return super.toString();
    }    @Override
    protected Object clone() throws CloneNotSupportedException {        return super.clone();
    }
}

Test

public static void main(String[] args) throws Exception{	// 創(chuàng)建父親(LiLiu)，兒子(LiWu)，孫子（LiLiu）并關(guān)聯(lián)
	Son father = new Son();
	father.setName("LiSi");
	Son son = new Son();
	son.setName("LiWu");
	Son grandSon = new Son();
	grandSon.setName("LiLiu");
	father.setSon(son);
	son.setSon(grandSon);	// 調(diào)用clone方法
	Son fatherCopy =  (Son) father.clone();	boolean flag1 = fatherCopy==father;	boolean flag2 = fatherCopy.getSon() == son;	boolean flag3 = fatherCopy.getSon().getSon() == grandSon;	// 比較克隆后的地址
	System.out.println(flag1);// false
	System.out.println(flag2);// true
	System.out.println(flag3);// true
	// 比較Name
	flag1= fatherCopy.getName()==father.getName();
	flag2 = fatherCopy.getSon().getName() == son.getName();
	flag3 = fatherCopy.getSon().getSon().getName() == grandSon.getName();
	System.out.println(flag1);// true
	System.out.println(flag2);// true
	System.out.println(flag3);// true
	
	//將對(duì)象寫到流里    
	ByteArrayOutputStream byteOut=new ByteArrayOutputStream();    
	ObjectOutputStream objOut=new ObjectOutputStream(byteOut);    
	objOut.writeObject(father);	//從流里讀出來    
	ByteArrayInputStream byteIn=new ByteArrayInputStream(byteOut.toByteArray());    
	ObjectInputStream objInput=new ObjectInputStream(byteIn);
    fatherCopy = (Son) objInput.readObject();
	flag1= fatherCopy==father;
	flag2 = fatherCopy.getSon() == son;
	flag3 = fatherCopy.getSon().getSon() == grandSon;
	System.out.println(flag1);// false
	System.out.println(flag2);// false
	System.out.println(flag3);// false
	
	// 比較Name
	flag1= fatherCopy.getName()==father.getName();
	flag2 = fatherCopy.getSon().getName() == son.getName();
	flag3 = fatherCopy.getSon().getSon().getName() == grandSon.getName();
	System.out.println(flag1);// false
	System.out.println(flag2);// false
	System.out.println(flag3);// false}

It is easy to see from the above code and running results that if the object implements Cloneable and overrides the clone method without performing any operations, calling clone is a shallow clone. Using object streams to write objects to the stream and then read them out is deep cloning.

Thinking: Since implementing the Cloneable interface and rewriting the clone interface can only perform shallow cloning. However, if the reference type attributes of the class (and the reference type attributes of the attribute) are shallow cloned, until there is no reference type attribute or the reference type attribute is null, a deep clone will be formed as a whole. Both the reference type attribute of the object and the application type attribute of the attribute implement Coloneable, override the clone method and call it in the clone method.

protected Object clone() throws CloneNotSupportedException {
      Son result = (Son) super.clone();	if (son != null) {
		result.son = (Son) son.clone();
	}    return result;
}

Personally, I think that when choosing the deep cloning method, it should be based on the complexity of the object, such as whether the reference type attribute has multiple layers of reference type attribute relationships. If the object has only one or two layers of reference type attributes, it is more convenient to choose the method mentioned in the reflection. Otherwise, use object flow.

For more related interview questions, please visit: java interview questions and answers

The above is the detailed content of Talk about your understanding of deep cloning and shallow cloning in java. For more information, please follow other related articles on the PHP Chinese website!