.toArray (yeni Sınıfım [0]) veya .toArray (yeni Sınıfım [myList.size ()])?

Bir ArrayListim olduğunu varsayarsak

ArrayList<MyClass> myList;

Ve Array'ı aramak istiyorum, kullanmak için bir performans nedeni var mı

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

bitmiş

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

?

Daha az ayrıntılı olduğu için ikinci stili tercih ediyorum ve derleyicinin boş dizinin gerçekten oluşturulmadığından emin olacağını varsaydım, ancak bunun doğru olup olmadığını merak ediyorum.

Tabii ki, vakaların% 99'unda şu veya bu şekilde bir fark yaratmaz, ancak normal kodum ve optimize edilmiş iç döngülerim arasında tutarlı bir stil tutmak istiyorum ...

Buna karşılık, Hotspot 8'deki en hızlı sürüm:

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

Sonuçları ve kod aşağıda, jmh kullanarak bir mikro benchmark çalıştırmak var boş bir dizi ile sürüm tutarlı bir şekilde bir dizi ile sürümden daha iyi gösteriyor. Var olan bir diziyi doğru boyutta yeniden kullanabiliyorsanız sonucun farklı olabileceğini unutmayın.

Deney sonuçları (mikrosaniye cinsinden puan, daha küçük = daha iyi):

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

Referans için kod:

@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]);
  }
}

Benzer sonuçları, tam analizi ve tartışmayı Bloglar Dizilerinde Bilgili Diziler bölümünde bulabilirsiniz . Özetlemek gerekirse: JVM ve JIT derleyicisi, ucuz bir yeni doğru boyut dizisi oluşturmasını ve başlatmasını sağlayan çeşitli optimizasyonlar içerir ve diziyi kendiniz oluşturursanız bu optimizasyonlar kullanılamaz.

İtibariyle Java 5 ArrayList doğru boyutuna sahip (veya daha büyük) ise, dizi zaten doldurulacaktır. sonuç olarak

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

bir dizi nesnesi oluşturur, doldurur ve "arr" a döndürür. Diğer yandan

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

iki dizi oluşturacak. İkincisi, uzunluğu 0 olan bir MyClass dizisidir. Dolayısıyla, hemen atılacak bir nesne için bir nesne oluşturma vardır. Kaynak kodunun önerdiği gibi, derleyici / JIT bunu oluşturmamak için optimize edemez. Ayrıca, sıfır uzunluklu nesnenin kullanılması toArray () - yöntemi içinde döküm (ler) ile sonuçlanır.

ArrayList.toArray () kaynağına bakın:

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;
}

Sadece bir nesne yaratılacak ve (örtük fakat yine de pahalı) dökümlerden kaçınacak şekilde ilk yöntemi kullanın.

JetBrains Intellij Idea denetiminden:

Bir koleksiyonu diziye dönüştürmek için iki stil vardır: önceden boyutlandırılmış bir dizi ( c.toArray (yeni String [c.size ()] gibi) ) veya boş bir dizi ( c.toArray (new String [ 0]) .

Eski Java sürümlerinde, uygun boyutta bir dizi oluşturmak için gerekli olan yansıma çağrısı oldukça yavaş olduğundan, önceden boyutlandırılmış dizi kullanılması önerilir. Bununla birlikte, OpenJDK 6'nın geç güncellemelerinden bu yana, bu çağrı içselleştirildi ve boş dizi sürümünün performansını önceden boyutlandırılmış sürümle karşılaştırıldığında aynı ve bazen daha da iyi hale getirdi. Boyut ve toArray çağrısı arasında bir veri yarışı mümkün olduğundan, önceden boyutlandırılmış bir dizinin geçirilmesi tehlikelidir çünkü toplama işlemi sırasında eşzamanlı olarak daraltılmışsa, dizinin sonunda fazladan boşluğa neden olabilir.

Bu inceleme, tek biçimli stili izlemeye izin verir: boş bir dizi (modern Java'da önerilir) veya önceden boyutlandırılmış bir dizi (eski Java sürümlerinde veya HotSpot tabanlı olmayan JVM'lerde daha hızlı olabilir) kullanarak.

Modern JVM'ler bu durumda yansıtıcı dizi yapısını optimize eder, bu nedenle performans farkı küçüktür. Koleksiyonu böyle bir kaynak kodunda iki kez adlandırmak harika bir fikir değil, bu yüzden ilk yöntemi kullanmam. İkincisinin bir başka avantajı, senkronize ve eşzamanlı koleksiyonlarla çalışmasıdır. Optimizasyon yapmak istiyorsanız, boş diziyi tekrar kullanın (boş diziler değiştirilemez ve paylaşılabilir) veya bir profiler (!) Kullanın.

toArray, geçirilen dizinin doğru boyutta olup olmadığını (yani, listenizdeki öğelere sığacak kadar büyük) olup olmadığını denetler ve bunu kullanır. Sonuç olarak dizinin boyutu gerekenden daha küçükse, yeni bir dizi refleks olarak oluşturulur.

Sizin durumunuzda, sıfır büyüklüğünde bir dizi değiştirilemez, bu nedenle güvenli bir şekilde statik bir son değişkene yükseltilebilir, bu da kodunuzu biraz daha temiz hale getirebilir, bu da her çağrıda dizinin oluşturulmasını önler. Yine de yöntemin içinde yeni bir dizi oluşturulacak, bu nedenle okunabilirlik optimizasyonu.

Muhtemelen daha hızlı sürüm doğru bir boyuttaki diziyi geçmek, ancak bu kodun bir performans darboğu olduğunu kanıtlayamazsanız , aksi kanıtlanmadıkça çalışma zamanı performansına okunabilirliği tercih edin.

İlk durum daha verimlidir.

Çünkü ikinci durumda:

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

çalışma zamanı aslında boş bir dizi (sıfır boyutlu) oluşturur ve ardından toArray yönteminin içinde gerçek verilere uyacak başka bir dizi oluşturulur. Bu oluşturma aşağıdaki kod kullanılarak yansıma kullanılarak yapılır (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;
}

İlk formu kullanarak, ikinci bir dizi oluşturmaktan ve yansıma kodundan da kaçınabilirsiniz.

İkincisi marjinal olarak okunabilir, ancak buna değmeyecek kadar az gelişme var. İlk yöntem daha hızlıdır, çalışma zamanında dezavantaj yoktur, bu yüzden kullanıyorum. Ama ikinci şekilde yazıyorum, çünkü yazmak daha hızlı. Sonra IDE'm bir uyarı olarak işaretler ve düzeltmeyi önerir. Tek bir tuşa basarak, kodu ikinci türden birinciye dönüştürür.

'ToArray' öğesini doğru boyutta diziyle kullanmak, alternatif önce sıfır boyutlu diziyi sonra doğru boyutta diziyi oluşturacağından daha iyi performans gösterir. Ancak, dediğiniz gibi, farkın ihmal edilebilir olması muhtemeldir.

Ayrıca, javac derleyicisinin herhangi bir optimizasyon gerçekleştirmediğini unutmayın. Bu günlerde tüm optimizasyonlar çalışma zamanında JIT / HotSpot derleyicileri tarafından gerçekleştirilir. Herhangi bir JVMs 'toArray' etrafında herhangi bir optimizasyon farkında değilim.

O halde, sorunuzun cevabı büyük ölçüde bir stil meselesidir, ancak tutarlılık uğruna, uyduğunuz herhangi bir kodlama standardının (belgelenmiş veya başka türlü) bir parçasını oluşturmalıdır.

tamsayı için örnek kod:

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