Java-implémenter la copie profonde et superficielle d'un tableau

j'essaie de comprendre le concept de copie superficielle vs profonde En Java. Il y a beaucoup d'articles et de questions et Réponses sur ce sujet, mais chaque fois que j'essaie d'implémenter ces concepts dans un vrai code Java, tout devient flou pour moi.

L'une des réponses sur lesquelles je fonde mon interprétation est dans ce lien , où la copie profonde et superficielle est expliquée par des schémas.

je vais vous montrer ci-dessous mon implémentation pour chaque case:

• "Copie peu profonde:

j'ai pris pour mon exemple la méthode système.arraycopy() comme je l'ai lu dans plusieurs articles qu'il effectue une copie superficielle (avec le clone méthode

public class Test {

    public static void main(String[] args) {
        NameValue[] instance1 = {
                new NameValue("name1", 1),
                new NameValue("name2", 2),
                new NameValue("name3", 3),
        };
        NameValue[] instance2 = new NameValue[instance1.length];

        // Print initial state
        System.out.println("Arrays before shallow copy:");
        System.out.println("Instance 1: " + Arrays.toString(instance1));
        System.out.println("Instance 2: " + Arrays.toString(instance2));

        // Perform shallow copy
        System.arraycopy(instance1, 0, instance2, 0, 3);

        // Change instance 1
        for (int i = 0; i < 3; i++) {
            instance1[i].change();
        }

        // Print final state
        System.out.println("Arrays after shallow copy:");
        System.out.println("Instance 1: " + Arrays.toString(instance1));
        System.out.println("Instance 2: " + Arrays.toString(instance2));
    }

    private static class NameValue {
        private String name;
        private int value;

        public NameValue(String name, int value) {
            super();
            this.name = name;
            this.value = value;
        }

        public void change() {
            this.name = this.name + "-bis";
            this.value = this.value + 1;
        }

        @Override
        public String toString() {
            return this.name + ": " + this.value;
        }
    }
}

Le résultat de l'exécution des principales méthodes est comme suit:

Arrays before shallow copy:
Instance 1: [name1: 1, name2: 2, name3: 3]
Instance 2: [null, null, null]
Arrays after shallow copy:
Instance 1: [name1-bis: 2, name2-bis: 3, name3-bis: 4]
Instance 2: [name1-bis: 2, name2-bis: 3, name3-bis: 4]

ce résultat est un conformément au schéma du lien précédent:

• copie en Profondeur:

j'ai pris pour cet exemple la méthode tableaux.copyOf () comme je l'ai lu dans de nombreux articles qu'il effectue une copie profonde (avec les tableaux .copyOfRange method)

public static void main(String[] args) {
    NameValue[] instance1 = {
            new NameValue("name1", 1),
            new NameValue("name2", 2),
            new NameValue("name3", 3),
    };
    NameValue[] instance2 = new NameValue[instance1.length];

    // Print initial state
    System.out.println("Arrays before deep copy:");
    System.out.println("Instance 1: " + Arrays.toString(instance1));
    System.out.println("Instance 2: " + Arrays.toString(instance2));

    // Perform deep copy
    instance2 = Arrays.copyOf(instance1, 3);

    // Change instance 1
    for (int i = 0; i < 3; i++) {
        instance2[i].change();
    }

    // Print final state
    System.out.println("Arrays after deep copy:");
    System.out.println("Instance 1: " + Arrays.toString(instance1));
    System.out.println("Instance 2: " + Arrays.toString(instance2));
}

qui affiche:

Arrays before deep copy:
Instance 1: [name1: 1, name2: 2, name3: 3]
Instance 2: [null, null, null]
Arrays after deep copy:
Instance 1: [name1-bis: 2, name2-bis: 3, name3-bis: 4]
Instance 2: [name1-bis: 2, name2-bis: 3, name3-bis: 4]

si nous basons la logique de la copie profonde sur le schéma précédent, cela devrait être le résultat:

Comme vous pouvez le remarquer, le résultat de l'exécution de la méthode main est différente de la logique du schéma ci-dessus.

Toute explication sera la bienvenue.