Apakah lebih baik menggunakan System.arraycopy (…) daripada loop for untuk menyalin array?

Saya ingin membuat array baru dari objek yang mengumpulkan dua array yang lebih kecil.

Mereka tidak boleh nol, tetapi ukurannya mungkin 0.

Saya tidak dapat memilih di antara dua cara ini: apakah sama atau lebih efisien (misalnya system.arraycopy () menyalin seluruh bagian)?

MyObject[] things = new MyObject[publicThings.length+privateThings.length];
System.arraycopy(publicThings, 0, things, 0, publicThings.length);
System.arraycopy(privateThings, 0, things,  publicThings.length, privateThings.length);

atau

MyObject[] things = new MyObject[publicThings.length+privateThings.length];
for (int i = 0; i < things.length; i++) {
    if (i<publicThings.length){
        things[i] = publicThings[i]
    } else {
        things[i] = privateThings[i-publicThings.length]        
    }
}

Apakah satu-satunya perbedaan tampilan kode?

EDIT: terima kasih untuk pertanyaan terkait, tetapi mereka tampaknya memiliki diskusi yang belum terpecahkan:

Apakah benar-benar lebih cepat if it is not for native types: byte [], Object [], char []? dalam semua kasus lain, pemeriksaan tipe dijalankan, yang akan menjadi kasus saya dan karenanya akan setara ... bukan?

Pada pertanyaan terkait lainnya, mereka mengatakan bahwa the size matters a lot, untuk ukuran> 24 system.arraycopy () menang, untuk lebih kecil dari 10, manual for loop lebih baik ...

Sekarang saya benar-benar bingung.

public void testHardCopyBytes()
{
    byte[] bytes = new byte[0x5000000]; /*~83mb buffer*/
    byte[] out = new byte[bytes.length];
    for(int i = 0; i < out.length; i++)
    {
        out[i] = bytes[i];
    }
}

public void testArrayCopyBytes()
{
    byte[] bytes = new byte[0x5000000]; /*~83mb buffer*/
    byte[] out = new byte[bytes.length];
    System.arraycopy(bytes, 0, out, 0, out.length);
}

Saya tahu tes JUnit sebenarnya bukan yang terbaik untuk benchmarking, tetapi
testHardCopyBytes membutuhkan 0,157 detik untuk menyelesaikannya
dan
testArrayCopyBytes membutuhkan 0,086 detik untuk menyelesaikannya.

Saya pikir itu tergantung pada mesin virtual, tetapi sepertinya itu menyalin blok memori daripada menyalin elemen array tunggal. Ini benar-benar akan meningkatkan kinerja.

EDIT:
Sepertinya kinerja System.arraycopy ada di mana-mana. Ketika String digunakan sebagai pengganti byte, dan array kecil (ukuran 10), saya mendapatkan hasil ini:

    String HC:  60306 ns
    String AC:  4812 ns
    byte HC:    4490 ns
    byte AC:    9945 ns

Berikut adalah tampilannya saat array berukuran 0x1000000. Sepertinya System.arraycopy pasti menang dengan array yang lebih besar.

    Strs HC:  51730575 ns
    Strs AC:  24033154 ns
    Bytes HC: 28521827 ns
    Bytes AC: 5264961 ns

Aneh sekali!

Terima kasih, Daren, untuk menunjukkan bahwa salinan referensi berbeda. Itu membuat masalah ini jauh lebih menarik!

Arrays.copyOf(T[], int)lebih mudah dibaca. Internaly yang digunakannya System.arraycopy()adalah panggilan asli.

Anda tidak bisa mendapatkannya lebih cepat!

Itu tergantung pada mesin virtual, tetapi System.arraycopy akan memberi Anda yang terdekat dengan kinerja asli.

Saya telah bekerja selama 2 tahun sebagai pengembang java untuk sistem tertanam (di mana kinerja adalah prioritas besar) dan di mana pun System.arraycopy dapat digunakan, saya sebagian besar telah menggunakannya / melihatnya digunakan dalam kode yang ada. Itu selalu lebih disukai daripada loop ketika kinerja menjadi masalah. Jika kinerja bukan masalah besar, saya akan pergi dengan loop. Jauh lebih mudah dibaca.

Alih-alih mengandalkan spekulasi dan informasi yang mungkin sudah ketinggalan zaman, saya menjalankan beberapa benchmark menggunakan caliper. Faktanya, Caliper hadir dengan beberapa contoh, termasuk CopyArrayBenchmarkyang mengukur pertanyaan ini dengan tepat! Yang harus Anda lakukan hanyalah lari

mvn exec:java -Dexec.mainClass=com.google.caliper.runner.CaliperMain -Dexec.args=examples.CopyArrayBenchmark

Hasil saya didasarkan pada VM Server 64-Bit Java HotSpot (TM) Oracle, 1.8.0_31-b13, yang berjalan pada MacBook Pro pertengahan 2010 (macOS 10.11.6 dengan Intel Arrandale i7, 8 GiB RAM). Saya tidak percaya bahwa memposting data waktu mentah itu berguna. Sebaliknya, saya akan meringkas kesimpulan dengan visualisasi pendukung.

Singkatnya:

• Menulis forloop manual untuk menyalin setiap elemen ke dalam array yang baru dibuat tidak pernah menguntungkan, baik untuk array pendek atau array panjang.
• Arrays.copyOf(array, array.length)dan array.clone()keduanya cepat secara konsisten. Kedua teknik ini hampir identik dalam kinerja; mana yang kamu pilih adalah soal selera.
• System.arraycopy(src, 0, dest, 0, src.length)hampir secepat dan , tetapi tidak secara konsisten. (Lihat kasus untuk 50000 s.) Karena itu, dan verbositas panggilan, saya akan merekomendasikan jika Anda memerlukan kontrol yang baik atas elemen mana yang akan disalin di mana.Arrays.copyOf(array, array.length)array.clone()intSystem.arraycopy()

Berikut plot waktunya:

Menjalankan metode asli seperti Arrays.copyOf(T[], int)memang memiliki beberapa overhead tetapi itu tidak berarti bahwa itu tidak secepat Anda mengeksekusinya menggunakan JNI.

Cara termudah adalah dengan menulis patokan dan tes.

Anda dapat memeriksa itu Arrays.copyOf(T[], int)lebih cepat dari forloop normal Anda .

Kode patokan dari sini : -

public void test(int copySize, int copyCount, int testRep) {
    System.out.println("Copy size = " + copySize);
    System.out.println("Copy count = " + copyCount);
    System.out.println();
    for (int i = testRep; i > 0; --i) {
        copy(copySize, copyCount);
        loop(copySize, copyCount);
    }
    System.out.println();
}

public void copy(int copySize, int copyCount) {
    int[] src = newSrc(copySize + 1);
    int[] dst = new int[copySize + 1];
    long begin = System.nanoTime();
    for (int count = copyCount; count > 0; --count) {
        System.arraycopy(src, 1, dst, 0, copySize);
        dst[copySize] = src[copySize] + 1;
        System.arraycopy(dst, 0, src, 0, copySize);
        src[copySize] = dst[copySize];
    }
    long end = System.nanoTime();
    System.out.println("Arraycopy: " + (end - begin) / 1e9 + " s");
}

public void loop(int copySize, int copyCount) {
    int[] src = newSrc(copySize + 1);
    int[] dst = new int[copySize + 1];
    long begin = System.nanoTime();
    for (int count = copyCount; count > 0; --count) {
        for (int i = copySize - 1; i >= 0; --i) {
            dst[i] = src[i + 1];
        }
        dst[copySize] = src[copySize] + 1;
        for (int i = copySize - 1; i >= 0; --i) {
            src[i] = dst[i];
        }
        src[copySize] = dst[copySize];
    }
    long end = System.nanoTime();
    System.out.println("Man. loop: " + (end - begin) / 1e9 + " s");
}

public int[] newSrc(int arraySize) {
    int[] src = new int[arraySize];
    for (int i = arraySize - 1; i >= 0; --i) {
        src[i] = i;
    }
    return src;
}

System.arraycopy()menggunakan JNI (Java Native Interface) untuk menyalin larik (atau sebagian darinya), jadi sangat cepat, seperti yang dapat Anda konfirmasikan di sini

Tidak mungkin itu Arrays.copyOflebih cepat daripada System.arraycopykarena ini adalah implementasi dari copyOf:

public static int[] copyOf(int[] original, int newLength) {
    int[] copy = new int[newLength];
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

System.arraycopy()adalah panggilan asli yang melakukan operasi penyalinan langsung di memori. Salinan memori tunggal akan selalu lebih cepat daripada for loop Anda