.toArray (MyClass baru [0]) atau .toArray (MyClass baru [myList.size ()]))?

Dengan asumsi saya memiliki ArrayList

ArrayList<MyClass> myList;

Dan saya ingin memanggil toArray, apakah ada alasan kinerja untuk digunakan

MyClass[] arr = myList.toArray(new MyClass[myList.size()]);

lebih

MyClass[] arr = myList.toArray(new MyClass[0]);

?

Saya lebih suka gaya kedua, karena kurang verbose, dan saya berasumsi bahwa kompiler akan memastikan array kosong tidak benar-benar dibuat, tapi saya sudah bertanya-tanya apakah itu benar.

Tentu saja, dalam 99% kasus tidak ada bedanya dengan satu cara atau yang lain, tapi saya ingin menjaga gaya yang konsisten antara kode normal saya dan loop internal yang dioptimalkan ...

Secara berlawanan, versi tercepat, di Hotspot 8, adalah:

MyClass[] arr = myList.toArray(new MyClass[0]);

Saya telah menjalankan tolok ukur mikro menggunakan jmh hasil dan kode di bawah ini, menunjukkan bahwa versi dengan array kosong secara konsisten mengungguli versi dengan array yang telah ditentukan. Perhatikan bahwa jika Anda dapat menggunakan kembali array yang ada dengan ukuran yang benar, hasilnya mungkin berbeda.

Hasil benchmark (skor dalam mikrodetik, lebih kecil = lebih baik):

Benchmark                      (n)  Mode  Samples    Score   Error  Units
c.a.p.SO29378922.preSize         1  avgt       30    0.025 ▒ 0.001  us/op
c.a.p.SO29378922.preSize       100  avgt       30    0.155 ▒ 0.004  us/op
c.a.p.SO29378922.preSize      1000  avgt       30    1.512 ▒ 0.031  us/op
c.a.p.SO29378922.preSize      5000  avgt       30    6.884 ▒ 0.130  us/op
c.a.p.SO29378922.preSize     10000  avgt       30   13.147 ▒ 0.199  us/op
c.a.p.SO29378922.preSize    100000  avgt       30  159.977 ▒ 5.292  us/op
c.a.p.SO29378922.resize          1  avgt       30    0.019 ▒ 0.000  us/op
c.a.p.SO29378922.resize        100  avgt       30    0.133 ▒ 0.003  us/op
c.a.p.SO29378922.resize       1000  avgt       30    1.075 ▒ 0.022  us/op
c.a.p.SO29378922.resize       5000  avgt       30    5.318 ▒ 0.121  us/op
c.a.p.SO29378922.resize      10000  avgt       30   10.652 ▒ 0.227  us/op
c.a.p.SO29378922.resize     100000  avgt       30  139.692 ▒ 8.957  us/op

Untuk referensi, kodenya:

@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
public class SO29378922 {
  @Param({"1", "100", "1000", "5000", "10000", "100000"}) int n;
  private final List<Integer> list = new ArrayList<>();
  @Setup public void populateList() {
    for (int i = 0; i < n; i++) list.add(0);
  }
  @Benchmark public Integer[] preSize() {
    return list.toArray(new Integer[n]);
  }
  @Benchmark public Integer[] resize() {
    return list.toArray(new Integer[0]);
  }
}

Anda dapat menemukan hasil yang serupa, analisis lengkap, dan diskusi di posting blog Array of Wisdom of the Ancients . Untuk meringkas: kompiler JVM dan JIT berisi beberapa optimisasi yang memungkinkannya untuk membuat dan menginisialisasi array dengan ukuran baru dengan murah, dan optimisasi tersebut tidak dapat digunakan jika Anda membuat array sendiri.

Pada ArrayList di Java 5 , array akan diisi sudah jika memiliki ukuran yang tepat (atau lebih besar). Karena itu

MyClass[] arr = myList.toArray(new MyClass[myList.size()]);

akan membuat satu objek array, mengisinya dan mengembalikannya ke "arr". Di samping itu

MyClass[] arr = myList.toArray(new MyClass[0]);

akan membuat dua array. Yang kedua adalah array dari MyClass dengan panjang 0. Jadi ada penciptaan objek untuk objek yang akan dibuang segera. Sejauh kode sumber menunjukkan compiler / JIT tidak dapat mengoptimalkan yang ini sehingga tidak dibuat. Selain itu, dengan menggunakan objek zero-length menghasilkan casting dalam metode toArray () -.

Lihat sumber ArrayList.toArray ():

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

Gunakan metode pertama sehingga hanya satu objek yang dibuat dan menghindari coran (implisit tapi tetap mahal).

Dari inspeksi JetBrains Intellij Idea:

Ada dua gaya untuk mengonversi koleksi menjadi array: baik menggunakan array ukuran awal (seperti c.toArray (String baru [c.size ()]) )) atau menggunakan array kosong (seperti c.toArray (new String [ 0]) .

Dalam versi Java yang lebih lama menggunakan array ukuran pra-rekomendasikan, karena panggilan refleksi yang diperlukan untuk membuat array dengan ukuran yang tepat sangat lambat. Namun karena pembaruan OpenJDK 6 yang terlambat, panggilan ini terintinsifikasi, menjadikan kinerja versi array kosong sama dan terkadang bahkan lebih baik, dibandingkan dengan versi pra-ukuran. Melewati array pra-ukuran berbahaya untuk koleksi bersamaan atau disinkronkan karena perlombaan data dimungkinkan antara ukuran dan panggilan toArray yang dapat menghasilkan nulls ekstra di akhir array, jika koleksi secara bersamaan menyusut selama operasi.

Inspeksi ini memungkinkan untuk mengikuti gaya seragam: baik menggunakan array kosong (yang direkomendasikan di Jawa modern) atau menggunakan array pra-ukuran (yang mungkin lebih cepat di versi Java yang lebih lama atau JVM berbasis non-HotSpot).

JVM modern mengoptimalkan konstruksi array reflektif dalam hal ini, sehingga perbedaan kinerja sangat kecil. Menamai koleksi dua kali dalam kode boilerplate seperti itu bukan ide bagus, jadi saya akan menghindari metode pertama. Keuntungan lain dari yang kedua adalah bahwa ia bekerja dengan koleksi yang disinkronkan dan bersamaan. Jika Anda ingin membuat optimasi, gunakan kembali array kosong (array kosong tidak dapat diubah dan dapat dibagikan), atau gunakan profiler (!).

toArray memeriksa apakah array yang dikirimkan memiliki ukuran yang tepat (yaitu, cukup besar untuk memuat elemen dari daftar Anda) dan jika demikian, gunakan itu. Akibatnya jika ukuran array yang disediakan lebih kecil dari yang dibutuhkan, array baru akan dibuat secara refleksif.

Dalam kasus Anda, array dengan ukuran nol, tidak dapat diubah, sehingga dapat dengan aman dinaikkan ke variabel final statis, yang mungkin membuat kode Anda sedikit lebih bersih, yang menghindari membuat array pada setiap permintaan. Larik baru akan dibuat di dalam metode, jadi itu adalah pembacaan optimalisasi.

Mungkin versi yang lebih cepat adalah untuk melewatkan array dengan ukuran yang benar, tetapi kecuali Anda dapat membuktikan bahwa kode ini adalah hambatan kinerja, lebih suka keterbacaan untuk kinerja runtime sampai terbukti sebaliknya.

Kasus pertama lebih efisien.

Itu karena dalam kasus kedua:

MyClass[] arr = myList.toArray(new MyClass[0]);

runtime sebenarnya membuat array kosong (dengan ukuran nol) dan kemudian di dalam metode toArray membuat array lain agar sesuai dengan data aktual. Pembuatan ini dilakukan dengan menggunakan refleksi menggunakan kode berikut (diambil dari jdk1.5.0_10):

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        a = (T[])java.lang.reflect.Array.
    newInstance(a.getClass().getComponentType(), size);
System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

Dengan menggunakan formulir pertama, Anda menghindari pembuatan array kedua dan juga menghindari kode refleksi.

Yang kedua sedikit lebih mudah dibaca, tetapi ada sedikit perbaikan sehingga tidak layak. Metode pertama lebih cepat, tanpa kerugian saat runtime, jadi itulah yang saya gunakan. Tapi saya menulisnya dengan cara kedua, karena lebih cepat untuk mengetik. Kemudian IDE saya menandainya sebagai peringatan dan menawarkan untuk memperbaikinya. Dengan satu penekanan tombol, itu mengubah kode dari tipe kedua ke yang pertama.

Menggunakan 'toArray' dengan array dengan ukuran yang benar akan berkinerja lebih baik karena alternatif akan membuat pertama array berukuran nol kemudian array dengan ukuran yang benar. Namun, seperti yang Anda katakan, perbedaannya mungkin diabaikan.

Juga, perhatikan bahwa kompiler javac tidak melakukan optimasi apa pun. Hari-hari ini semua optimasi dilakukan oleh kompiler JIT / HotSpot saat runtime. Saya tidak mengetahui adanya optimasi di sekitar 'toArray' di JVM.

Maka, jawaban atas pertanyaan Anda sebagian besar adalah masalah gaya tetapi demi konsistensi harus menjadi bagian dari standar pengkodean apa pun yang Anda patuhi (apakah didokumentasikan atau tidak).

kode sampel untuk integer:

Integer[] arr = myList.toArray(new integer[0]);