【无标题】deep clone 相关问题

class中含有references variables的

protected 类型在 parent/subclass中的accessibility

Java:由Object.clone()而引出的protected权限问题_BAOLIANG196的博客-CSDN博客

 deep clone方法 -- override Object.clone()：

 @Override
    public Object clone() throws CloneNotSupportedException{
       return (MyComplexType)super.clone();
 }

class中含有references variables的deep clone： 

import java.util.ArrayList;
import java.util.List;

public class deepCloneDemo {

    public static void main(String[] args) throws CloneNotSupportedException {
        System.out.println("=============================== shadow copy ======================");
        MySimpleType my = new MySimpleType(2,3);
        System.out.println(my);
        MySimpleType my2 = (MySimpleType) my.clone(); //since it's the primative type var, it get deep copied.
        System.out.println("my2: " + my2);

        my2.a = 100;
        System.out.println("now my2: " + my2);
        System.out.println("now my: " + my);
        System.out.println("===============================");
        System.out.println("=============================== deep clone without changes in /* */======================");
        MyComplexType mc = new MyComplexType(2,3);
        System.out.println(mc);
        MyComplexType mc2 = (MyComplexType) mc.clone();
        System.out.println("mc2:" + mc2);

        mc2.a = 10;
        mc2.b = 5;
        System.out.println("now only int[] in mc2 should be a deep copy: " + mc2);
        System.out.println("now int[] in mc should be no changes: " + mc);
        System.out.println("===============================");

        MyComplexType mc22 = (MyComplexType) mc.clone();
        int[] arr2 = new int[3];
        for(int i = 0; i < 3; i++){
            arr2[i] = 100;
        }
        mc22.arr = arr2;
        System.out.println("now mc22: " + mc22);

        mc22.list.get(0).set(0, 1); //since List<List> is a reference of reference, so the inner list is still  a shadow copy
        System.out.println("now list<list> in mc22 is still shadow clone: " + mc22);
        System.out.println("now list<list> in mc also changing: " + mc); //List<List> is still a shadow clone

        System.out.println("===============================deep clone with changes in /* */=================");

        MyComplexType mc3 = (MyComplexType) mc.clone(); //use deep clone
        mc3.list.get(0).set(0, 100);
        System.out.println("mc3:" + mc3);
        System.out.println("now mc: " + mc);

    }
}

class MySimpleType implements Cloneable{
    int a;
    int b;
    public MySimpleType(int x, int y){
        a = x;
        b = y;
    }

    @Override
    public String toString(){
        return "(" + a + ", " + b + ")";
    }

    @Override
    public Object clone() throws CloneNotSupportedException{
        MySimpleType newObject = (MySimpleType)super.clone();
        return newObject;
    }
}

class MyComplexType implements Cloneable{
    int a;
    int b;
    int[] arr;
    List<Integer> l;
    List<List<Integer>> list;

     public MyComplexType(int x, int y){
        a = x;
        b = y;
        arr = new int[a];
        for(int i = 0 ; i < a; i++){
            arr[i] = b;
        }
        l = new ArrayList<>();
        for(int i = 0 ; i < a; i++) {
            l.add(y);
        }
        list = new ArrayList<>();
        list.add(new ArrayList<>());
        list.get(0).add(a);
        list.get(0).add(b);
    }

    @Override
    public String toString(){
        return "(" + a + ", " + b + ", " + arr.toString()  + ", " + arr[0] + ", "+ arr[1] + "... "  + l.toString() + ", " + list.toString() + ")";
    }

    @Override
    public Object clone() throws CloneNotSupportedException{
        MyComplexType newObject = (MyComplexType)super.clone();

         //to ensure all components to be correctly cloned
        newObject.arr = (int[]) arr.clone();

        List<Integer> lcopy = new ArrayList<>();
        for(Integer n : l) {
            lcopy.add(n);
        }

        List<List<Integer>> listCopy = new ArrayList<>();
        for(List<Integer> line :list){
            List<Integer> lineCopy = new ArrayList<>();
            for(Integer node : line) {
                lineCopy.add(node);
            }
            listCopy.add(lineCopy);
        }
        newObject.list = listCopy;


        return newObject;
    }
}

不包含/**/中的output:

============== deep clone without changes in /* */======================
(2, 3, [I@3fb6a447, 3, 3... [3, 3], [[2, 3]])
mc2:(2, 3, [I@3fb6a447, 3, 3... [3, 3], [[2, 3]])
now only int[] in mc2 should be a deep copy: (10, 5, [I@3fb6a447, 3, 3... [3, 3], [[2, 3]])
now int[] in mc should be no changes: (2, 3, [I@3fb6a447, 3, 3... [3, 3], [[2, 3]])
===============================
now mc22: (2, 3, [I@13a57a3b, 100, 100... [3, 3], [[2, 3]])
now list<list> in mc22 is still shadow clone: (2, 3, [I@13a57a3b, 100, 100... [3, 3], [[1, 3]])
now list<list> in mc also changing: (2, 3, [I@3fb6a447, 3, 3... [3, 3], [[1, 3]])

 包含/**/中的部分的所有output：

=============================== shadow copy ======================
(2, 3)
my2: (2, 3)
now my2: (100, 3)
now my: (2, 3)
===============================
=============================== deep clone without changes in /* */======================
(2, 3, [I@3fb6a447, 3, 3... [3, 3], [[2, 3]])
mc2:(2, 3, [I@13a57a3b, 3, 3... [3, 3], [[2, 3]])
now only int[] in mc2 should be a deep copy: (10, 5, [I@13a57a3b, 3, 3... [3, 3], [[2, 3]])
now int[] in mc should be no changes: (2, 3, [I@3fb6a447, 3, 3... [3, 3], [[2, 3]])
===============================
now mc22: (2, 3, [I@7ca48474, 100, 100... [3, 3], [[2, 3]])
now list<list> in mc22 is still shadow clone: (2, 3, [I@7ca48474, 100, 100... [3, 3], [[1, 3]])
now list<list> in mc also changing: (2, 3, [I@3fb6a447, 3, 3... [3, 3], [[2, 3]])
===============================deep clone with changes in /* */=================
mc3:(2, 3, [I@337d0578, 3, 3... [3, 3], [[100, 3]])
now mc: (2, 3, [I@3fb6a447, 3, 3... [3, 3], [[2, 3]])