Neden ilk kapasiteye sahip bir ArrayList başlatmalıyım?

Her zamanki kurucusu ArrayList:

ArrayList<?> list = new ArrayList<>();

Ancak başlangıç ​​kapasitesi için bir parametreye sahip aşırı yüklenmiş bir kurucu da var:

ArrayList<?> list = new ArrayList<>(20);

ArrayListİstediğimiz gibi ekleyebildiğimizde, başlangıç ​​kapasitesine sahip bir an oluşturmak neden yararlıdır ?

Boyutunun ne olacağını önceden biliyorsanız ArrayList, başlangıç ​​kapasitesini belirtmek daha etkilidir. Bunu yapmazsanız, liste büyüdükçe dahili dizinin tekrar tekrar atanması gerekir.

Son liste ne kadar büyük olursa, yeniden tahsisleri önleyerek daha fazla zaman kazanırsınız.

Bununla birlikte, ön ayırma olmadan bile n, bir arkasına eleman yerleştirmenin ArrayListtoplam O(n)zaman alması garanti edilir . Başka bir deyişle, bir öğeyi eklemek, itfa edilmiş sabit zamanlı bir işlemdir. Bu, her yeniden tahsisin dizinin boyutunu katlanarak, tipik olarak bir faktör ile arttırmasıyla elde edilir 1.5. Bu yaklaşımla, toplam işlem sayısının olduğu gösterilebilirO(n) .

Çünkü ArrayLista, dinamik olarak yeniden boyutlandırma dizi , bir başlangıç (varsayılan), sabit boyutu ile bir dizi olarak uygulanan demektir veri yapısı. Bu dolduğunda, dizi çift boyutlu bir diziye genişletilir. Bu işlem maliyetlidir, bu yüzden mümkün olduğunca azını istersiniz.

Bu nedenle, üst sınırınızın 20 öğe olduğunu biliyorsanız, başlangıç ​​uzunluğu 20 olan diziyi oluşturmak varsayılan olarak, örneğin 15'i kullanmaktan daha iyidir ve sonra yeniden boyutlandırın 15*2 = 30ve genişletme için döngüleri harcarken yalnızca 20'yi kullanın.

Not - AmitG'nin dediği gibi, genişleme faktörü uygulamaya özgüdür (bu durumda (oldCapacity * 3)/2 + 1)

Arraylist'in varsayılan boyutu 10'dur .

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
    this(10);
    } 

Eğer 100 veya daha fazla kayıt ekleyecekseniz, bellek yeniden tahsis yükünü görebilirsiniz.

ArrayList<?> list = new ArrayList<>();    
// same as  new ArrayList<>(10);      

Dolayısıyla, Arraylist'te saklanacak elemanların sayısı hakkında herhangi bir fikriniz varsa, 10 ile başlamak ve daha sonra artırmak yerine bu boyutta Arraylist oluşturmak daha iyidir.

Aslında 2 ay önce konuyla ilgili bir blog yazısı yazdım . Makale C # için List<T>ama Java'nın ArrayListçok benzer bir uygulaması var. Yana ArrayListdinamik bir dizi kullanılarak uygulanır, bu talep üzerine boyutunda artar. Dolayısıyla kapasite oluşturucunun nedeni optimizasyon amaçlıdır.

Bu yeniden boyutlandırma işlemlerinden biri gerçekleştiğinde, ArrayList dizinin içeriğini eskisinin iki katı kapasiteye sahip yeni bir diziye kopyalar. Bu işlem O (n) süresinde çalışır .

Misal

Boyutun nasıl ArrayListartacağına dair bir örnek :

10
16
25
38
58
... 17 resizes ...
198578
297868
446803
670205
1005308

Liste kapasiteli başlar Yani 1011. madde eklenir, bu tarafından artıştır 50% + 1için 16. 17. maddede bu ArrayListoran tekrar artırılır 25. Şimdi, istenen kapasitenin zaten bilindiği bir liste oluşturduğumuz örneği düşünün 1000000. ArrayListBoyut oluşturucu olmadan oluşturma çağrılırArrayList.add 1000000 O (1) 'i normal olarak veya O (n) ' yi yeniden boyutlandırmada alan süreleri .

1000000 + 16 + 25 + ... + 670205 + 1005308 = 4015851 işlem

Yapıcıyı kullanarak ve ardından çağırarak bunu karşılaştırın ArrayList.add O (1) ' de çalışacağı garanti edilen .

1000000 + 1000000 = 2000000 işlem

Java vs C #

Java yukarıdaki gibidir, 10her boyuttan başlayarak ve yeniden boyutlandırılır 50% + 1. C # başlar4 ve her yeniden boyutlandırmada iki katına çıkarak çok daha agresif bir şekilde artar. 1000000C # kullanımları için yukarıdan örnek ekler 3097084işlemleri.

Referanslar

• C # 's Listesindeki blog yazım <T>
• Java'nın ArrayList kaynak kodu

Bir ArrayList öğesinin başlangıç ​​boyutunun ayarlanması, örneğin ArrayList<>(100), dahili belleğin yeniden tahsis edilme sayısını azaltır.

Misal:

ArrayList example = new ArrayList<Integer>(3);
example.add(1); // size() == 1
example.add(2); // size() == 2, 
example.add(2); // size() == 3, example has been 'filled'
example.add(3); // size() == 4, example has been 'expanded' so that the fourth element can be added. 

Yukarıdaki örnekte gördüğünüz gibi - ArrayListgerekiyorsa genişletilebilir. Bunun size göstermediği şey, Arraylist'in büyüklüğünün genellikle iki katına çıkmasıdır (ancak yeni boyutun uygulamanıza bağlı olduğunu unutmayın). Oracle'dan alıntılar :

"Her ArrayList örneğinin bir kapasitesi vardır. Kapasite, öğeleri listede saklamak için kullanılan dizinin boyutudur. Her zaman en az liste boyutu kadar büyüktür. Öğeler bir ArrayList'e eklendiğinde kapasitesi otomatik olarak artar. Büyüme politikasının ayrıntıları, bir unsur eklemenin sabit amortisman süresi maliyetine sahip olmasının ötesinde belirtilmemiştir. "

Açıkçası, ne tür bir menzil tutacağınız hakkında hiçbir fikriniz yoksa, boyutu ayarlamak muhtemelen iyi bir fikir olmaz - ancak, belirli bir menziliniz varsa, ilk kapasitenin ayarlanması bellek verimliliğini artıracaktır. .

ArrayList birçok değer içerebilir ve büyük ilk eklemeler yaparken ArrayList'e, sonraki öğe için daha fazla yer ayırmaya çalıştığında CPU döngülerini boşa harcamamaya başlamak için daha büyük bir depolama alanı ayırmasını söyleyebilirsiniz. Böylece başlangıçta biraz yer ayırmak daha verimlidir.

Bu, her bir nesne için yeniden tahsis için olası çabalardan kaçınmaktır.

int newCapacity = (oldCapacity * 3)/2 + 1;

dahili new Object[]olarak oluşturulur. Arrayliste eleman eklediğinizde JVM'nin
oluşturulması için çaba harcanması new Object[]gerekir. Yeniden tahsis için yukarıdaki kodunuz (düşündüğünüz herhangi bir algo) yoksa, ne zaman çağırırsanız arraylist.add()o new Object[]zaman yaratılmalıdır, ki bu anlamsızdır ve eklenecek her nesne için boyutu 1 arttırmak için zaman kaybediyoruz. Bu nedenle Object[]aşağıdaki formülle boyutunu arttırmak daha iyidir .
(JSL, dinamik olarak büyüyen arraylist için her seferinde 1 oranında büyümek yerine aşağıda verilen tahmin formülünü kullanmıştır.

int newCapacity = (oldCapacity * 3)/2 + 1;

Her ArrayList'in init kapasite değeri "10" ile oluşturulduğunu düşünüyorum. Her neyse, yapıcı içinde kapasite ayarlamadan bir ArrayList oluşturursanız, varsayılan bir değerle oluşturulur.

Onun bir optimizasyon olduğunu söyleyebilirim. Başlangıç ​​kapasitesi olmayan ArrayList'te ~ 10 boş satır bulunur ve bir ekleme yaptığınızda genişler.

Tam olarak öğe sayısını içeren bir listeye sahip olmak için trimToSize () öğesini çağırmanız gerekir

Deneyimlerime göre ArrayList, bir başlangıç ​​kapasitesi vermek yeniden tahsis maliyetlerinden kaçınmanın güzel bir yoludur. Ama bir uyarı var. Yukarıda belirtilen tüm öneriler, kişinin sadece eleman sayısının kabaca bir tahmini biliniyorsa başlangıç ​​kapasitesini sağlaması gerektiğini söylüyor. Ancak herhangi bir fikrim olmadan bir başlangıç ​​kapasitesi vermeye çalıştığımızda, ayrılan ve kullanılmayan bellek miktarı bir atık olacaktır, çünkü liste gerekli sayıda öğeye doldurulduktan sonra asla gerekli olmayabilir. Diyorum ki, kapasite tahsis ederken başlangıçta pragmatik olabilir ve daha sonra çalışma zamanında gerekli minimum kapasiteyi bilmenin akıllı bir yolunu bulabiliriz. ArrayList adlı bir yöntem sağlar ensureCapacity(int minCapacity). Ama sonra, akıllı bir yol buldu ...

ArrayList'i initialCapacity ile ve bu test olmadan test ettim ve şaşırtıcı bir sonuç elde
ettim

list1Sttop-list1Start = 14
list2Sttop-list2Start = 10

Ancak LOOP_NUMBER değerini 1.000.000 olarak ayarladığımda sonuç şu şekilde değişir:

list1Stop-list1Start = 40
list2Stop-list2Start = 66

Sonunda, nasıl çalıştığını anlayamadım ?!
Basit kod:

 public static final int LOOP_NUMBER = 100000;

public static void main(String[] args) {

    long list1Start = System.currentTimeMillis();
    List<Integer> list1 = new ArrayList();
    for (int i = 0; i < LOOP_NUMBER; i++) {
        list1.add(i);
    }
    long list1Stop = System.currentTimeMillis();
    System.out.println("list1Stop-list1Start = " + String.valueOf(list1Stop - list1Start));

    long list2Start = System.currentTimeMillis();
    List<Integer> list2 = new ArrayList(LOOP_NUMBER);
    for (int i = 0; i < LOOP_NUMBER; i++) {
        list2.add(i);
    }
    long list2Stop = System.currentTimeMillis();
    System.out.println("list2Stop-list2Start = " + String.valueOf(list2Stop - list2Start));
}

Windows8.1 ve jdk1.7.0_80 üzerinde test yaptım