Méthode de clonage pour les tableaux Java

Question

Que retourne exactement la méthode clone() en Java lorsqu'elle est utilisée sur un tableau ? Renvoie-t-elle un nouveau tableau dont les données ont été copiées à partir de l'original ?

Ex :

int[] a = {1,2,3};
int[] b = a.clone();

Answer 1

Lorsque le clone est invoquée sur un tableau, elle renvoie une référence à un nouveau tableau qui contient (ou référence) les mêmes éléments que le tableau source.

Ainsi, dans votre exemple, int[] a est une instance d'objet séparée créée sur le tas et int[] b est une instance d'objet distincte créée sur le tas. (N'oubliez pas que tous les tableaux sont des objets).

    int[] a = {1,2,3};
    int[] b = a.clone();

    System.out.println(a == b ? "Same Instance":"Different Instance");
    //Outputs different instance

Si l'on modifie int[] b les changements ne seraient pas répercutés sur les int[] a puisqu'il s'agit de deux instances d'objets distinctes.

    b[0] = 5;
    System.out.println(a[0]);
    System.out.println(b[0]);
    //Outputs: 1
    //         5

Cela devient légèrement plus compliqué lorsque le tableau source contient des objets. Le tableau clone renvoie une référence à un nouveau tableau, qui référence les mêmes objets que le tableau source.

Ainsi, si nous avons la classe Dog ...

    class Dog{

        private String name;

        public Dog(String name) {
            super();
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

    }

et je crée et alimente un tableau de type Dog ...

    Dog[] myDogs = new Dog[4];

    myDogs[0] = new Dog("Wolf");
    myDogs[1] = new Dog("Pepper");
    myDogs[2] = new Dog("Bullet");
    myDogs[3] = new Dog("Sadie");

puis cloner le chien...

    Dog[] myDogsClone = myDogs.clone();

les tableaux font référence aux mêmes éléments...

    System.out.println(myDogs[0] == myDogsClone[0] ? "Same":"Different");
    System.out.println(myDogs[1] == myDogsClone[1] ? "Same":"Different");
    System.out.println(myDogs[2] == myDogsClone[2] ? "Same":"Different");
    System.out.println(myDogs[3] == myDogsClone[3] ? "Same":"Different");
    //Outputs Same (4 Times)

Cela signifie que si l'on modifie un objet auquel on accède par l'intermédiaire du tableau cloné, les changements seront répercutés lorsque l'on accède au même objet dans le tableau source, puisqu'ils renvoient à la même référence.

    myDogsClone[0].setName("Ruff"); 
    System.out.println(myDogs[0].getName());
    //Outputs Ruff

Toutefois, les modifications apportées au tableau lui-même n'affecteront que ce tableau.

    myDogsClone[1] = new Dog("Spot");
    System.out.println(myDogsClone[1].getName());
    System.out.println(myDogs[1].getName());
    //Outputs Spot
    //        Pepper

Si vous comprenez généralement comment fonctionnent les références d'objets, il est facile de comprendre comment les tableaux d'objets sont affectés par le clonage et les modifications. Pour en savoir plus sur les références et les primitives, je vous suggère de lire l'excellent article suivant article .

Gist du code source

Answer 2

clone() crée et renvoie une copie de cet objet. La signification précise de "copie" peut dépendre de la classe de l'objet. L'intention générale est que, pour tout objet x, l'expression :

 x.clone() != x

Sera vrai, et que l'expression :

 x.clone().getClass() == x.getClass()

Ce sera vrai, mais ce ne sont pas des exigences absolues.

Alors que c'est généralement le cas :

 x.clone().equals(x)

sera vrai, il ne s'agit pas d'une exigence absolue.

Par convention, l'objet retourné doit être obtenu en appelant super.clone . Si une classe et toutes ses superclasses (à l'exception d'Object) obéissent à cette convention, il en résultera que x.clone().getClass() == x.getClass() .