参考、浅拷贝和深拷贝

Question

I have been researching and reading what these three (Reference copy, Shallow copy and Deep copy) methods do and how to create them; and I am still having a hard time understanding how to implement the said methods in my code.

The first method suppose to be a reference method (refCopy), the second should be a shallow method (shalCopy) and last a deep copy method(deepCopy). Not sure if these are correct. Any help on how to execute these copies correctly will be greatly appreciated.

This is my code so far:

public class ArrayRefCopy implements Cloneable {
    private static int n = 3;
    private static StringBuffer[] buf = new StringBuffer[4];
    public static void main(String[] args){

        StringBuffer[] hel = new StringBuffer[n];
        hel[0] = new StringBuffer("hello");
        hel[1] = new StringBuffer("hallo");
        hel[2] = new StringBuffer("hey");

        refCopy(hel);
        System.out.println(Arrays.toString(hel));
        shalCopy(hel);
        System.out.println(Arrays.toString(hel));


    }

    public static StringBuffer[] refCopy(StringBuffer[] bra){

        StringBuffer[] ber = bra;
        return ber;
    }

    public static StringBuffer[] shalCopy(StringBuffer[] bar){

        return buf = bar;
    }

    public static StringBuffer[] deepCopy(StringBuffer[] bri){

        StringBuffer[] deep = new StringBuffer[n];
        return deep = bri.clone();
    }
}

=========================================================================

I changed the last two methods to this (created objects in them):

public static StringBuffer[] shalCopy(StringBuffer[] bar){
        StringBuffer[] buf = new StringBuffer[n];
        return buf = Arrays.copyOf(bar, n);
    }

    public static StringBuffer[] deepCopy(StringBuffer[] bri){

        StringBuffer[] deep = new StringBuffer[n];
        return deep = bri.clone();
    }

But when I do this:

StringBuffer[] hel = new StringBuffer[n];
        hel[0] = new StringBuffer("hello");
        hel[1] = new StringBuffer("hallo");
        hel[2] = new StringBuffer("hey");

        StringBuffer[] hal = new StringBuffer[n];
        hal = deepCopy(hel);


        System.out.println(hal.equals(hel));

It gives me false. I thought clone would completely copy the object with its values. Why is it giving me false?

UPDATE:

public static StringBuffer[] shalCopy(StringBuffer[] bar){
        StringBuffer[] buf = new StringBuffer[bar.length];
        for(int i = 0; i < bar.length; i++){
            buf[i] = bar[i];
        }

            return buf;
        }




    public static StringBuffer[] deepCopy(StringBuffer[] bri){

        StringBuffer[] deep = new StringBuffer[bri.length];
        for(int i=0; i < bri.length; i++){
            bri[i] = new StringBuffer(bri[i]);
            deep[i] = bri[i];
        }

        return deep;

    }

Answer 1

Your refCopy() is fine.

shalCopy() needs to construct a new array, then copy in the input StringBuffer references so it shares those StringBuffer objects. Write a loop or use arrayCopy .

deepCopy() needs to construct a new array and then make copies of all the input StringBuffers .

Can you fill in the details? If we do your assignment for you, you might not learn from it as well.

Update: Your updated shalCopy() method gets the right result in this case but (1) it should use bar.length (its input array length) instead of assuming its input array has length n , and (2) the first assignment buf = new StringBuffer[n] is pointless and misleading since the code immediately replaces that with another array. Also, this will be more instructive if you write an explicit loop rather than call Arrays.copyOf() .

Your updated deepCopy() does not get the right result, and it repeats the above problems. clone() is not what's needed, is not so useful in general, and does not shed any light on the problem at hand, that is, it's not instructive here. Instead, try constructing a new array and using a loop to (deep) copy all the StringBuffer objects, not their references.

Here's how you can tell if your code works:

• A reference copy dest = refCopy(source) should make the variable dest refer to the same instance as source . So changing eg dest[0] = null will also change source[0] .
• A shallow copy dest = shalCopy(source) should make the variable dest refer to a new array that contains the very same instances that are in source . So changing dest[0] = null will not change source[0] , but modifying a shared instance, eg dest[1].append("!") will modify source[1] .
• A deep copy dest = deepCopy(source) should make the variable dest refer to a separate array that contains separate instances that are not in source . So neither of the above changes to dest will modify source .

Answer 2

Reference copy = A new variable pointing to the original object.

Shallow copy = Create a new copy of the original object and assign identical values to its primitive properties but use the same references as the original object for the properties that refer to other objects.

Deep copy = Create a new copy of the original object and recursively create new copies for every object reference in the original object references chain.

Example:

class C {
int b;
A ref1; // in shallow copy, use the same object reference. In deep copy, create a copy on this class instance
}

---

To answer your second question on why hal.equals(hel) returns false: It's because this is the same as == check. To compare two arrays contents, you'd have to use Arrays.equals(array1, array2);

Answer 3

你的答案在这里：参考副本、浅副本和深副本https://medium.com/swlh/reference-copy-shallow-copy-and-deep-copy-63f9418c9c51