web-dev-qa-db-fra.com

Méthode de clonage pour Java des tableaux

Qu'est-ce que la méthode clone () dans Java) renvoie quand elle est utilisée sur un tableau? Renvoie-t-elle un nouveau tableau avec des données copiées à partir de l'original?

Ex:

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

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

Donc, dans votre exemple, int[] a est une instance d'objet distinct créée sur le tas et int[] b est une instance d'objet distinct créée sur le segment de mémoire. (Rappelez-vous 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 devait modifier int[] b les modifications ne seront pas répercutées sur int[] a puisque les deux sont des instances d'objet 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. La méthode clone renverra une référence à un nouveau tableau, qui fait référence aux mêmes objets que le tableau source.

Donc, 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 remplis 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");

alors clone dog ...

    Dog[] myDogsClone = myDogs.clone();

les tableaux se réfèrent 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 nous modifions un objet accédé via le tableau cloné, les modifications seront répercutées lorsque nous accéderons au même objet dans le tableau source, car elles pointent vers la même référence.

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

Cependant, 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 le fonctionnement des références d'objet, il est facile de comprendre l'impact du clonage et des modifications sur les tableaux d'objets. Pour mieux comprendre les références et les primitives, je suggère de lire cet excellent article .

Gist of Source Code

83
Kevin Bowersox

La méthode 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()

Sera vrai, mais ce ne sont pas des exigences absolues.

Alors qu’il est généralement le cas que:

 x.clone().equals(x)

sera vrai, ce n'est pas une exigence absolue.

Par convention, l'objet retourné doit être obtenu en appelant super.clone. Si une classe et toutes ses super-classes (à l'exception de Object) obéissent à cette convention, ce sera le cas que x.clone().getClass() == x.getClass().

3
9ine