Copie d'un tableau d'objets

Je veux faire une copie d'un tableau d'objets à l'aide d'un constructeur.

public class PositionList {
    private Position[] data = new Position[0];

public PositionList(PositionList other, boolean deepCopy) {
        if (deepCopy){
            size=other.getSize();
            data=new Position[other.data.length];
            for (int i=0;i<data.length;i++){
            data[i]=other.data[i];
            }

Cependant, ce que j'ai ci-dessus, pour quelque raison n'est pas de travail. J'ai des tests automatisés que je dirige, et sa a défaut de ces tests. Donc, il y a une erreur ici que Im pas sûr de ce qu'il est.

OriginalL'auteur Snowman | 2010-10-16

  1. 22

    Ce que vous avez mis en place est un peu profonde copie. Pour mettre en œuvre un profonde de copie, vous devez
    changement

    data[i] = other.data[i];

    à quelque chose qui affecte un copie de other.data[i] à data[i]. Comment vous faites cela dépend de la Position classe. Les alternatives possibles sont:

    • un constructeur de copie:

      data[i] = new Position(other.data[i]);

    • une méthode de fabrique:

      data[i] = createPosition(other.data[i]);

    • clone:

      data[i] = (Position) other.data[i].clone();

    Notes:

    1. Le ci-dessus supposent que le constructeur de copie, de l'usine de méthode et méthode clone respectivement de mettre en œuvre le "droit" sorte de copie, en fonction de la Position de classe; voir ci-dessous.
    2. La clone approche ne fonctionnera que si Position explicitement le prend en charge, et cela est généralement considéré comme une solution insuffisante. En outre, vous devez être conscient du fait que le natif de mise en œuvre de clone (c'est à dire la Object.clone() méthode) une copie superficielle.

    En fait, le problème général de la mise en œuvre profonde de la copie en Java est compliqué. Dans le cas de la Position classe, on peut supposer que les attributs sont tous les types primitifs (par exemple, entiers ou en double), et donc une profonde peu profonde contre la copie, est discutable. Mais si il y a des attributs de référence, alors vous devez compter sur le constructeur de copie par défaut /méthode /méthode clone pour faire le genre de la copie que vous avez besoin. Dans chaque cas, il doit être programmé. Et dans le cas général (où vous avez à traiter avec des cycles), il est difficile et exige que chaque classe pour mettre en œuvre des méthodes spéciales.

    Il y a un autre potentiel moyen de copier un tableau d'objets. Si les objets dans le tableau sont serializable, alors vous pouvez les copier en utilisant ObjectOutputStream et ObjectInputStream sérialiser et puis désérialiser le tableau. Cependant:

    • c'est cher,
    • il ne fonctionne que si les objets sont (transitivement) serializable, et
    • les valeurs de toutes les transient champs ne soient pas copiés.

    La copie par la sérialisation n'est pas recommandé. Il serait mieux de soutenir le clonage ou d'une autre méthode.

    Dans l'ensemble, profond, la copie est préférable d'éviter en Java.

    Enfin, pour répondre à votre question au sujet de la Position classes constructeur de copie d'œuvres, je m'attends à quelque chose qui ressemble à ceci:

    public class Position {
    private int x;
    private int y;
    ...
    public Position(Position other) {
        this.x = other.x;
        this.y = other.y;
    }
    ...
}

    @Tortue dit, il n'y a pas quelque chose de magique. Vous mettez en œuvre un constructeur (à la main) qui initialise son état par la copie à partir d'une instance existante.

    Le constructeur de copie est celui dont j'ai besoin. Celui que vous avez ci-dessus a parfaitement fonctionné, mais je ne comprends pas. Donc, nous sommes en train de créer un nouveau Poste, mais qu'est-ce que cet argument que nous nourrir de lui, d'autres.data[i]? Pouvez-vous décrire comment cela fonctionne?
    C'est pas de la magie. Quelqu'un a besoin d'écrire un constructeur pour la Position de classe qui prend une instance de cette classe comme son seul argument et renvoie une copie en profondeur.
    Pas nécessairement clone() la copie en profondeur: par exemple, renvoie une copie de cette liste de tableaux, par exemple. (Les éléments eux-mêmes ne sont pas copiés.)
    Concernant la troisième option, clone() - assurez-vous que le Point met en œuvre Cloneable.
    Je veux créer une copie d'un Tableau d'Objets, ne les Tableaux.copyOf() créer une copie en profondeur ? Ce sont des objets de quelques classes personnalisées, qui n'a pas mis en œuvre les Clonable interface. stackoverflow.com/questions/18954873/...

    OriginalL'auteur Stephen C

  2. 2

    Quand vous dites:

    data[i]=other.data[i];

    Vous êtes juste de la copie d'une liste de références (en supposant que c'est un tableau d'objets). Si vous voulez faire une copie, vous devez utiliser new pour créer une nouvelle instance de chaque objet dans le tableau.

    Mais où pourrais-je utiliser de nouveau? Dans la boucle?
    Oui. Dans chaque itération, créer un new objet et l'ajouter à data.
    Ok Im confus. Alors je supprimer data=new Position[other.data.length]; pour le code j'ai ci-dessus et en quelque sorte l'ajouter dans la boucle?

    OriginalL'auteur Justin Ethier

  3. 1

    Au lieu de dire:

    data[i]=other.data[i]

    Vous voulez faire d'un constructeur de copie pour Position (en d'autres termes, un constructeur pour la Position que prend dans un autre Position et des copies de données primitifs (à l'intérieur) et de dire data[i]=new Position(other.data[i]);

    En fait votre "copie" constructeur de la PositionList est un constructeur de copie, bien que le constructeur de copie ne tendent à indiquer une copie en profondeur, de sorte que le deepCopy paramètre n'est pas nécessaire.

    -1 clone fait une copie superficielle pas une copie en profondeur. Il peut travailler OK pour les primitives et des objets immuables, mais à ne pas confondre avec une copie en profondeur.
    Nous sommes censés le faire sans le clone...
    c'est vrai, j'ai été en supposant que Position était un POJO, et donc, .clone() serait de travailler.
    Comment puis-je le faire sans clone?
    Ensuite, utilisez un constructeur de copie, comme ma solution alternative a dit. Cela dit, j'ai vraiment devrait avoir mis en place le "constructeur de copie" solution d'abord, en raison du fait que .clone() a des inconvénients.

    OriginalL'auteur Thomas

  4. 0

    Voici une fonction que j'utilise:

    function copy(arr) {
  return arr
    .map(x => Object
      .keys(x)
      .reduce((acc, y) => {
        acc[y] = x[y]
        return acc
      }, {}))
}

    Il ne fonctionne que sur les tableaux avec les objets avec un seul niveau.

    OriginalL'auteur Kainan

  5. -3

    Cela devrait faire une "profonde" copie

    int [] numbers = { 2, 3, 4, 5};

int [] numbersClone = (int[])numbers.clone();
    Cela fonctionne pour un tableau de primitives (comme les entiers), mais la question était à propos d'un tableau d'objets.

    OriginalL'auteur D Patrick