Les Collections.problème de copie de

Je veux que b1 et b2 de disposer de leurs propres ensembles d'éléments, puis b1 et b2 doit avoir ses propres éléments dans la mémoire de sorte que lorsque b1/b2 modifié, d'autres ne devraient pas être affectés.

buffer est un ArrayList contenant de nombreux éléments

List<Integer>  b1 = new ArrayList<Integer>(buffer.size()) ;
List<Integer>  b2 = new ArrayList<Integer>(buffer.size()) ) ;
Collections.copy(b1, buffer);
Collections.copy(b2, buffer);

Je reçois cette exception:

Exception in thread "main" 
java.lang.IndexOutOfBoundsException: Source: ne rentre pas dans dest 
à java.util.Les Collections.copier(Collections.java:531) 
sur des Arbres.containsSumPrint(Arbres.java:243) 
sur des Arbres.principale(Arbres.java:125)

OriginalL'auteur javaCollect | 2011-05-12

  1. 10

    La ArrayList(int) constructeur donne une List qui a une taille de 0, il assure que n éléments peuvent être ajoutés avant il doit réaffecter le tableau sous-jacent.

    Une meilleure façon, vous pouvez copier la liste est:

    b1.addAll(buffer);
b2.addAll(buffer);

    La sémantique est la même que lorsque vous avez ajouté des buffer.size() les valeurs null pour chaque tableau et appelé Collections.copy(b1,buffer);

    Si vous voulez une copie en profondeur (les éléments sont copiés), vous allez avoir à gérer chaque élément séparément 

    for(MyObject obj:buffer){
    b1.add(obj.clone());
    b2.add(obj.clone());
}
    après nous ne b1.addALL(tampon) permettra à la fois de la mémoire tampon et b1 avoir sa propre copie séparée de elemets?la modification de l'une incidence sur les autres?
    chacun aura sa propre collection que vous pouvez modifier séparément. Mais l'appel de b1.get(0).doSomething() affectera également b2.get(0) (ils restent les mêmes objets) mais des Entiers comme dans la question sont immuables de sorte que vous pouvez sortir avec elle partage les objets

    OriginalL'auteur ratchet freak

  2. 1

    La Collections.copy(...) javadoc dit ceci:

    "Les Copies de tous les éléments d'une liste dans une autre. Après l'opération, l'index de chaque élément copié dans la liste de destination sont identiques à ceux de son indice dans la liste source. La liste de destination doit être au moins aussi longue que la liste source. Si elle est plus longue, le reste des éléments dans la liste de destination ne sont pas affectés.".

    La ArrayList(int) constructeur crée une liste vide dont capacité (pas la taille!) est donné par l'argument.

    Depuis b1 est initialement vide, la copie d'un non-vide de la liste (à l'aide de copy) sera un échec, puisque la condition (en gras) n'est pas vrai (en général).

    Fondamentalement, Collections.copy(...) est pas la bonne méthode à utiliser.

    Ce que vous devez vraiment faire est ceci:

    List<Integer> b1 = new ArrayList<Integer>(buffer.size());
List<Integer> b2 = new ArrayList<Integer>(buffer.size());
b1.addAll(buffer);
b2.addAll(buffer);

    Je suis en supposant que vous n'avez pas vraiment souhaitez créer de nouvelles instances des éléments de la liste. Si vous le faites, je me dois de souligner que la création de nouvelles instances de Integer objets est un gaspillage de temps depuis Integer (comme les autres classes wrapper et String) est immuable la classe.

    Ne pas créer deux listes distinctes (copie) des objets, qui est ce que l'OP veut.

    OriginalL'auteur Stephen C

  3. 1

    Vous voulez une copie en profondeur de chaque élément. Il n'existe pas de méthode standard pour y parvenir, à cause profonde de la copie pourrait impliquer de copier les références imbriquées (collections) sur d'autres objets. La meilleure façon de le faire est de créer un constructeur de copie, de java.lang.Entier arrive à en avoir un! Donc, je pense que vous devriez faire quelque chose comme:

    List<Integer> buffer = Arrays.asList(new Integer[] { 0, 1, 2, 3, 4 });
List<Integer> b1 = new ArrayList<Integer>();
List<Integer> b2 = new ArrayList<Integer>();

for (Integer element : buffer) {
    b1.add(new Integer(element));
    b2.add(new Integer(element));
}

    Ceci crée en fait DEUX exemplaires, un pour chaque liste. Si l'une de ces listes contiennent les éléments d'origine, il suffit de ne:

    for (Integer element : buffer) {
    b1.add(new Integer(element));
    b2.add(element);
}

    Noter qu'il existe aussi la clonable interface. Je déconseille l'utilisation de ce parce que c'est facile de faire des erreurs avec les visées des classes, collections et sous-classement. Un constructeur de copie est beaucoup plus facile d'obtenir le droit. Voir cette page pour certains corroboration.

    EDIT: sur la re-lecture, peut-être que vous ne voulez pas profonde des copies, dans ce cas vous pouvez utiliser le "addAll' méthode décrite par d'autres. Cela vous permettra de créer plusieurs collections de même des instances de l'objet. Vous pouvez ensuite modifier le contenu/l'ordre des objets dans une collection sans affecter les autres collections. Toutefois, si vous modifiez un objet de l'instance, ce sera évidemment répercuté par tous les autres collections.

    Aussi, StephenC à juste titre remarquer que mon exemple ci-dessus est de la noisette. Je suis d'accord, il ne serait jamais 'copie' Entiers comme ça normalement, mais il aurait de sens que pour des objets personnalisés contenant des collections de références qui je pensais était la question ici.

    C'est de la noisette. À moins que l'OP est en train de faire quelque chose de bizarre, la création de nouveaux Integer objets est une perte de temps ... même si vous pensez que c'est ce qu'il a demandé.
    D'accord. Je suis en supposant que l'OP utilisé des nombres Entiers comme un exemple ici, et veut vraiment faire ce pour les objets de complexité arbitraire.

    OriginalL'auteur Adriaan Koster