Bir dizinin kopyasını oluşturma

aSürekli güncellenen bir dizi var . Diyelim a = [1,2,3,4,5]. Tam bir kopyasını almam ave çağırmam gerekiyor b. Eğer adeğişecek olsaydı [6,7,8,9,10], bhala olmalı [1,2,3,4,5]. Bunu yapmanın en iyi yolu nedir? forGibi bir döngü denedim :

for(int i=0; i<5; i++) {
    b[i]=a[i]
}

ancak bu düzgün çalışmıyor gibi görünüyor. Lütfen derin kopya gibi gelişmiş terimleri kullanmayın, çünkü bunun ne anlama geldiğini bilmiyorum.

System.arraycopy () kullanmayı deneyebilirsiniz

int[] src  = new int[]{1,2,3,4,5};
int[] dest = new int[5];

System.arraycopy( src, 0, dest, 0, src.length );

Ancak, çoğu durumda clone () kullanmak daha iyidir:

int[] src = ...
int[] dest = src.clone();

kullanabilirsiniz

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

de.

Şunun bir kopyasını oluşturmak istiyorsanız:

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

Bu yol:

int[] b = Arrays.copyOf(a, a.length);

Arrays.copyOfa.clone()küçük dizilerden daha hızlı olabilir . Her iki kopya öğesi de eşit derecede hızlı ancak clone () döndürür, Objectböylece derleyici örtük bir döküm eklemek zorundadır int[]. Bayt kodunda, bunun gibi bir şey görebilirsiniz:

ALOAD 1
INVOKEVIRTUAL [I.clone ()Ljava/lang/Object;
CHECKCAST [I
ASTORE 2

Http://www.journaldev.com/753/how-to-copy-arrays-in-java adresinden güzel açıklama

Java Dizisi Kopyalama Yöntemleri

Object.clone () : Object sınıfı clone () yöntemi sağlar ve java içindeki dizi de bir Object olduğundan, tam dizi kopyasını elde etmek için bu yöntemi kullanabilirsiniz. Dizinin kısmi kopyasını almak istiyorsanız bu yöntem size uymayacaktır.

System.arraycopy () : Sistem sınıfı arraycopy (), bir dizinin kısmi kopyasını yapmanın en iyi yoludur. Kopyalanacak toplam öğe sayısını ve kaynak ve hedef dizi dizin konumlarını belirtmenin kolay bir yolunu sunar. Örneğin, System.arraycopy (kaynak, 3, hedef, 2, 5) kaynağın 3. dizininden hedefin 2. dizinine başlayarak 5 öğeyi kaynaktan hedefe kopyalar.

Arrays.copyOf (): Bir dizinin ilk birkaç öğesini veya dizinin tam kopyasını kopyalamak istiyorsanız, bu yöntemi kullanabilirsiniz. Açıkçası System.arraycopy () gibi çok yönlü değil, aynı zamanda kafa karıştırıcı ve kullanımı kolay değil.

Arrays.copyOfRange () : Başlangıç ​​dizininin 0 olmadığı bir dizinin birkaç öğesinin kopyalanmasını istiyorsanız, kısmi diziyi kopyalamak için bu yöntemi kullanabilirsiniz.

Tüm bu "bir dizi kopyalamak için daha iyi yollar" gerçekten sorununuzu çözmeyecek bir duygu var.

Diyorsun

[...] gibi bir for döngüsü denedim ama bu düzgün çalışmıyor gibi görünüyor?

Bu döngüye bakıldığında, çalışmaması için açık bir neden yoktur ...

• ave bdizilerin bir şekilde dağılmasını sağlayın (ör. ave baynı diziye bakın) veya
• uygulamanız çok iş parçacıklı ve farklı iş parçacıkları aaynı anda diziyi okuyor ve güncelliyor .

Her iki durumda da, kopyalama yapmanın alternatif yolları altta yatan sorunu çözmez.

İlk senaryo için düzeltme açıktır. İkinci senaryoda, evreleri senkronize etmenin bir yolunu bulmanız gerekecektir. Atomik dizi sınıfları, atomik kopya yapıcıları veya klon yöntemleri olmadığından yardımcı olmazlar, ancak ilkel bir muteks kullanarak senkronize etmek hile yapar.

(Sorunuzda bunun gerçekten konu ile ilgili olduğunu düşünmemi sağlayan ipuçları var; örneğin asürekli değişen ifadeniz.)

Java'da Arrays.copyOf () yöntemini kullanmayı deneyebilirsiniz

int[] a = new int[5]{1,2,3,4,5};
int[] b = Arrays.copyOf(a, a.length);

Diziden uzunluk çağıran tüm çözüm, kodunuzu gereksiz boş denetleyicileri ekleyin

int[] a = {1,2,3,4,5};
int[] b = Arrays.copyOf(a, a.length);
int[] c = a.clone();

//What if array a comes as local parameter? You need to use null check:

public void someMethod(int[] a) {
    if (a!=null) {
        int[] b = Arrays.copyOf(a, a.length);
        int[] c = a.clone();
    }
}

Tekerleği icat etmemenizi ve gerekli tüm kontrollerin zaten yapıldığı hizmet sınıfını kullanmanızı tavsiye ederim. Apache ortaklarından ArrayUtils'i düşünün. Kod kısalır:

public void someMethod(int[] a) {
    int[] b = ArrayUtils.clone(a);
}

Orada bulabileceğiniz Apache müşterileri

Ayrıca kullanabilirsiniz Arrays.copyOfRange.

Örnek :

public static void main(String[] args) {
    int[] a = {1,2,3};
    int[] b = Arrays.copyOfRange(a, 0, a.length);
    a[0] = 5;
    System.out.println(Arrays.toString(a)); // [5,2,3]
    System.out.println(Arrays.toString(b)); // [1,2,3]
}

Bu yöntem benzer Arrays.copyOf, ancak daha esnektir. İkisi System.arraycopyde kaputun altında kullanıyor .

Bakınız :

• https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html
• https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html
• http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/8u40-b25/java/util/Arrays.java?av=f

Bir dizinin sıfırdan güvenli bir kopyası için, Object.clone()bu yanıtta sağlanan yöntemle isteğe bağlı olarak da kullanabilirsiniz .

int[] arrayToCopy = {1, 2, 3};
int[] copiedArray = Optional.ofNullable(arrayToCopy).map(int[]::clone).orElse(null);

Eğer değil çiğ dizilerle çalışmak ve gerekiyorsa ArrayListo zaman Arraysneye ihtiyacınız vardır. Kaynak koduna bakarsanız, bunlar bir dizinin kopyasını almanın kesinlikle en iyi yoludur. İyi bir savunma programlaması var çünküSystem.arraycopy()Mantıksal parametreleri beslerseniz yöntem çok sayıda kontrolsüz istisna atar .

Arrays.copyOf()İlk Nthöğeden öğeye yeni kısa diziye kopyalanacak olan herhangi birini kullanabilirsiniz .

public static <T> T[] copyOf(T[] original, int newLength)

Belirtilen diziyi keser veya doldurma işlemini null değerleriyle (gerekirse) kopyalar, böylece kopyanın belirtilen uzunluğu olur. Hem orijinal dizide hem de kopyada geçerli olan tüm dizinler için, iki dizi aynı değerleri içerecektir. Kopyada geçerli olan ancak orijinalde olmayan tüm dizinler için, kopya null içerir. Bu tür indeksler, yalnızca belirtilen uzunluk orijinal dizininkinden daha büyükse ve mevcut olacaktır. Sonuçta elde edilen dizi, orijinal diziyle tam olarak aynı sınıftadır.

2770
2771    public static <T,U> T[] More ...copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
2772        T[] copy = ((Object)newType == (Object)Object[].class)
2773            ? (T[]) new Object[newLength]
2774            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
2775        System.arraycopy(original, 0, copy, 0,
2776                         Math.min(original.length, newLength));
2777        return copy;
2778    }

ya Arrays.copyOfRange()da hile yapacak:

public static <T> T[] copyOfRange(T[] original, int from, int to)

Belirtilen dizinin belirtilen aralığını yeni bir diziye kopyalar. Aralığın başlangıç ​​endeksi (itibaren) sıfır ile orijinal arasında olmalıdır. Uzunluk, dahil. Original [from] öğesindeki değer, kopyanın ilk öğesine yerleştirilir (== original.length veya == - arasında değilse). Orijinal dizideki sonraki öğelerin değerleri, kopyadaki sonraki öğelere yerleştirilir. Aralıktan büyük veya ona eşit olması gereken son dizinin orijinal dizini, orijinalden daha büyük olabilir. uzunluk - itibaren. Döndürülen dizinin uzunluğu - arasında olacaktır. Sonuçta elde edilen dizi, orijinal diziyle tam olarak aynı sınıftadır.

3035    public static <T,U> T[] More ...copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) {
3036        int newLength = to - from;
3037        if (newLength < 0)
3038            throw new IllegalArgumentException(from + " > " + to);
3039        T[] copy = ((Object)newType == (Object)Object[].class)
3040            ? (T[]) new Object[newLength]
3041            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
3042        System.arraycopy(original, from, copy, 0,
3043                         Math.min(original.length - from, newLength));
3044        return copy;
3045    }

Gördüğünüz gibi, bunların her ikisi de System.arraycopy, yapmaya çalıştığınız şeyin geçerli olduğu savunma mantığıyla sadece sarmalayıcı işlevleridir .

System.arraycopy dizileri kopyalamanın en hızlı yoludur.

2D dizilerle de benzer bir sorun yaşadım ve burada bitirdim. Ana diziyi kopyalayıp iç dizilerin değerlerini değiştiriyordum ve değerler her iki kopyada da değiştiğinde şaşırdım. Temel olarak her iki kopya da bağımsızdı ancak aynı iç dizilere referanslar içeriyordu ve istediğim şeyi elde etmek için iç dizilerin bir dizi kopyasını yapmak zorunda kaldım.

Muhtemelen OP'nin sorunu değil, ama umarım yine de yardımcı olabilir.