ArrayList nasıl klonlanır ve içeriği klonlanır?

ArrayListJava'da öğelerini nasıl klonlayabilir ve ayrıca klonlayabilirim?

Örneğin:

ArrayList<Dog> dogs = getDogs();
ArrayList<Dog> clonedList = ....something to do with dogs....

Ve içerideki nesnelerin clonedListköpek listesindekiyle aynı olmamasını beklerdim .

Öğeleri yinelemeniz ve bunları tek tek klonlamanız ve klonları gittiğinizde sonuç dizinize koymanız gerekir.

public static List<Dog> cloneList(List<Dog> list) {
    List<Dog> clone = new ArrayList<Dog>(list.size());
    for (Dog item : list) clone.add(item.clone());
    return clone;
}

Bunun çalışması için, tabii ki, arabirimi Doguygulamak Cloneableve clone()yöntemi geçersiz kılmak için sınıfınızı almak zorunda kalacaksınız .

Şahsen, Dog'a bir kurucu eklerdim:

class Dog
{
    public Dog()
    { ... } // Regular constructor

    public Dog(Dog dog) {
        // Copy all the fields of Dog.
    }
}

Sonra tekrarlayın (Varkhan'ın cevabında gösterildiği gibi):

public static List<Dog> cloneList(List<Dog> dogList) {
    List<Dog> clonedList = new ArrayList<Dog>(dogList.size());
    for (Dog dog : dogList) {
        clonedList.add(new Dog(dog));
    }
    return clonedList;
}

Bunun avantajı, Java'daki kırık Klonlanabilir şeyler ile uğraşmanıza gerek kalmamasıdır. Ayrıca Java koleksiyonlarını kopyalama yönteminizle de eşleşir.

Başka bir seçenek de kendi ICloneable arayüzünüzü yazmak ve kullanmak olabilir. Bu şekilde klonlama için genel bir yöntem yazabilirsiniz.

Tüm standart koleksiyonlarda kopya oluşturucular bulunur. Onları kullan.

List<Double> original = // some list
List<Double> copy = new ArrayList<Double>(original); //This does a shallow copy

clone()birkaç hatayla tasarlanmıştır ( bu soruya bakın ), bu yüzden bundan kaçınmak en iyisidir.

Gönderen Etkili Java 2nd Edition , Madde 11: Geçersiz Kıl klon mantıklı

Cloneable ile ilgili tüm problemler göz önüne alındığında, diğer arayüzlerin onu genişletmemesi ve kalıtım için tasarlanan sınıfların (Madde 17) onu uygulamaması gerektiğini söylemek güvenlidir. Birçok eksikliğinden dolayı, bazı uzman programcılar, klon yöntemini asla geçersiz kılmamayı ve dizileri kopyalamak dışında asla çağırmayı seçmezler. Kalıtım için bir sınıf tasarlıyorsanız, iyi korunmuş bir korumalı klon yöntemi sağlamayı seçmezseniz, alt sınıfların Cloneable uygulamasının imkansız olacağını unutmayın.

Bu kitap aynı zamanda kopya kurucuların Klonlanabilir / klon üzerindeki avantajlarını da açıklar.

• Riske yatkın bir dil dışı nesne yaratma mekanizmasına güvenmezler
• İnce belgelenmiş sözleşmelere uygulanamaz şekilde uyulmasını istemiyorlar
• Nihai alanların doğru kullanımı ile çelişmezler
• Gereksiz kontrol edilmiş istisnalar atmıyorlar
• Oyuncu kadrosu gerektirmezler.

Kopya oluşturucuları kullanmanın başka bir avantajını göz önünde bulundurun: a'nız olduğunu HashSet sve onu a olarak kopyalamak istediğinizi varsayalım TreeSet. Klon yöntemi bu işlevselliği sunamıyoruz, ama bir dönüşüm yapıcısı ile kolay: new TreeSet(s).

Java 8, eleman köpeklerindeki kopya yapıcı veya klon yöntemini zarif ve kompakt bir şekilde çağırmak için yeni bir yol sağlar: Akımlar , lambdalar ve toplayıcılar .

Kopya oluşturucu:

List<Dog> clonedDogs = dogs.stream().map(Dog::new).collect(toList());

İfadeye yöntem başvurusuDog::new denir . Başka bir köpeği argüman olarak alan bir kurucuyu çağıran bir fonksiyon nesnesi oluşturur .Dog

Klonlama yöntemi [1]:

List<Dog> clonedDogs = dogs.stream().map(d -> d.clone()).collect(toList());

Bir ArrayList sonucunda

Veya, bir ArrayListgeri almanız gerekiyorsa (daha sonra değiştirmek isterseniz):

ArrayList<Dog> clonedDogs = dogs.stream().map(Dog::new).collect(toCollection(ArrayList::new));

Listeyi yerinde güncelleyin

dogsListenin orijinal içeriğini korumanız gerekmiyorsa , replaceAllyöntemi kullanabilir ve listeyi yerinde güncelleyebilirsiniz:

dogs.replaceAll(Dog::new);

Tüm örnekler varsayılmaktadır import static java.util.stream.Collectors.*;.

İçin toplayıcı ArrayListS

Son örnekten toplayıcı bir util yöntemine dönüştürülebilir. Bu çok yaygın bir şey olduğu için kişisel olarak kısa ve güzel olmasını seviyorum. Bunun gibi:

ArrayList<Dog> clonedDogs = dogs.stream().map(d -> d.clone()).collect(toArrayList());

public static <T> Collector<T, ?, ArrayList<T>> toArrayList() {
    return Collectors.toCollection(ArrayList::new);
}

[1] Not CloneNotSupportedException :

Bu çözümün işe yaraması için cloneyönteminin atıldığını beyan Dog etmemelidirCloneNotSupportedException . Bunun nedeni,map kontrol edilen istisnaları atmasına izin verilmemesidir.

Bunun gibi:

    // Note: Method is public and returns Dog, not Object
    @Override
    public Dog clone() /* Note: No throws clause here */ { ...

Bununla birlikte, bu büyük bir sorun olmamalı, çünkü bu zaten en iyi uygulamadır. ( Örneğin, Effectice Java bu tavsiyeyi verir.)

^{Gustavo'ya bunu kaydettiği için teşekkürler.}

Not:

Daha güzel bulursanız, aynı şeyi yapmak için yöntem referans sözdizimini kullanabilirsiniz:

List<Dog> clonedDogs = dogs.stream().map(Dog::clone).collect(toList());

Temel olarak elle tekrar etmeden üç yol vardır,

1 Oluşturucu kullanma

ArrayList<Dog> dogs = getDogs();
ArrayList<Dog> clonedList = new ArrayList<Dog>(dogs);

2 Kullanma addAll(Collection<? extends E> c)

ArrayList<Dog> dogs = getDogs();
ArrayList<Dog> clonedList = new ArrayList<Dog>();
clonedList.addAll(dogs);

3 Parametreli addAll(int index, Collection<? extends E> c)yöntem kullanmaint

ArrayList<Dog> dogs = getDogs();
ArrayList<Dog> clonedList = new ArrayList<Dog>();
clonedList.addAll(0, dogs);

Not: Belirtilen koleksiyon, işlem devam ederken değiştirilirse, bu işlemlerin davranışı tanımsız olacaktır.

Mevcut yeşil cevabın kötü olduğunu düşünüyorum , neden sorabilirsiniz?

• Çok fazla kod eklemeniz gerekebilir
• Kopyalanacak tüm Listeleri listelemenizi ve bunu yapmanızı gerektirir

Serileştirmenin de kötü imo olması, her yere Serializable eklemeniz gerekebilir.

Peki çözüm nedir:

Java Deep-Cloning kütüphanesi Klonlama kütüphanesi , nesneleri derin klonlayan küçük, açık kaynaklı (apache lisansı) bir java kütüphanesidir. Nesnelerin Klonlanabilir arabirimi uygulaması gerekmez. Etkili bir şekilde, bu kütüphane HERHANGİ BİR java nesnesini klonlayabilir. Önbelleğe alınan nesnenin değiştirilmesini istemiyorsanız veya nesnelerin derin bir kopyasını oluşturmak istediğinizde yani önbellek uygulamalarında kullanılabilir.

Cloner cloner=new Cloner();
XX clone = cloner.deepClone(someObjectOfTypeXX);

Https://github.com/kostaskougios/cloning adresinden kontrol edin

Bir yol buldum, listeyi serileştirmek / serisini kaldırmak için json kullanabilirsiniz. Serileştirilmiş liste, serileştirilmediğinde orijinal nesneye başvuruda bulunmaz.

Gson kullanma:

List<CategoryModel> originalList = new ArrayList<>(); // add some items later
String listAsJson = gson.toJson(originalList);
List<CategoryModel> newList = new Gson().fromJson(listAsJson, new TypeToken<List<CategoryModel>>() {}.getType());

Bunu jackson ve diğer herhangi bir json kütüphanesini kullanarak da yapabilirsiniz.

Bu seçeneği her zaman kullandım:

ArrayList<Dog> clonedList = new ArrayList<Dog>(name_of_arraylist_that_you_need_to_Clone);

ArrayListEl ile klonlamanız gerekir (üzerinde yineleyerek ve her öğeyi yenisine kopyalayarak ArrayList), çünkü clone()sizin için yapmayacaktır. Bunun nedeni, içerdiği nesnelerin kendilerini ArrayListuygulamamalarıdır Clonable.

Düzenleme : ... ve tam olarak Varkhan'ın kodunun yaptığı budur.

Kötü bir yol, yansımayla yapmaktır. Bunun gibi bir şey benim için çalıştı.

public static <T extends Cloneable> List<T> deepCloneList(List<T> original) {
    if (original == null || original.size() < 1) {
        return new ArrayList<>();
    }

    try {
        int originalSize = original.size();
        Method cloneMethod = original.get(0).getClass().getDeclaredMethod("clone");
        List<T> clonedList = new ArrayList<>();

        // noinspection ForLoopReplaceableByForEach
        for (int i = 0; i < originalSize; i++) {
            // noinspection unchecked
            clonedList.add((T) cloneMethod.invoke(original.get(i)));
        }
        return clonedList;
    } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
        System.err.println("Couldn't clone list due to " + e.getMessage());
        return new ArrayList<>();
    }
}

List<Dog> dogs;
List<Dog> copiedDogs = dogs.stream().map(dog -> SerializationUtils.clone(dog)).Collectors.toList());

Bu her köpeği derin kopyalar

Diğer posterler doğrudur: listeyi tekrarlamanız ve yeni bir listeye kopyalamanız gerekir.

Ancak ... Listedeki nesneler değişmezse - bunları klonlamanız gerekmez. Nesneniz karmaşık bir nesne grafiğine sahipse, bunların da değişmez olması gerekir.

Değişmezliğin bir diğer yararı da güvenli olmasıdır.

Genel bir şablon türü kullanan bir çözüm:

public static <T> List<T> copyList(List<T> source) {
    List<T> dest = new ArrayList<T>();
    for (T item : source) { dest.add(item); }
    return dest;
}

nesneler için clone () yöntemini geçersiz kılar

class You_class {

    int a;

    @Override
    public You_class clone() {
        You_class you_class = new You_class();
        you_class.a = this.a;
        return you_class;
    }
}

ve Vector obj veya ArraiList obj için .clone () öğesini çağırın.

Commons-lang-2.3.jar kullanarak java kütüphanesini klon listesine almanın kolay yolu

bağlantı indir commons-lang-2.3.jar

Nasıl kullanılır

oldList.........
List<YourObject> newList = new ArrayList<YourObject>();
foreach(YourObject obj : oldList){
   newList.add((YourObject)SerializationUtils.clone(obj));
}

Umarım bu yardımcı olabilir.

: D

Paket import org.apache.commons.lang.SerializationUtils;

Bir yöntem var SerializationUtils.clone(Object);

Misal

this.myObjectCloned = SerializationUtils.clone(this.object);

Bir varlık nesnesini ve bir java.util.List nesnesini klonlayabilen bir lib geliştirdim. Kavanozu https://drive.google.com/open?id=0B69Sui5ah93EUTloSktFUkctN0U adresinden indirin ve cloneListObject (Liste listesi) statik yöntemini kullanın. Bu yöntem yalnızca Liste'yi değil tüm varlık öğelerini de klonlar.

Aşağıdakiler benim için çalıştı.

Dog.java içinde

public Class Dog{

private String a,b;

public Dog(){} //no args constructor

public Dog(Dog d){ // copy constructor
   this.a=d.a;
   this.b=d.b;
}

}

 -------------------------

 private List<Dog> createCopy(List<Dog> dogs) {
 List<Dog> newDogsList= new ArrayList<>();
 if (CollectionUtils.isNotEmpty(dogs)) {
 dogs.stream().forEach(dog-> newDogsList.add((Dog) SerializationUtils.clone(dog)));
 }
 return newDogsList;
 }

Burada createCopy yönteminden oluşturulan yeni liste SerializationUtils.clone () ile oluşturulur. Bu nedenle, yeni listede yapılan herhangi bir değişiklik orijinal listeyi etkilemez

ArrayList'in derin bir kopyasını yapmanın gerçekten kolay bir yolunu bulduğumu düşünüyorum. Bir String ArrayList arrayA kopyalamak istediğinizi varsayarsak.

ArrayList<String>arrayB = new ArrayList<String>();
arrayB.addAll(arrayA);

Sizin için işe yaramıyorsa bana bildirin.