Java'da ArrayList üzerinden LinkedList ne zaman kullanılır?

Her zaman sadece kullanmak için bir oldum:

List<String> names = new ArrayList<>();

Arayüzü taşınabilirlik için tür adı olarak kullanıyorum , böylece bunlar gibi sorular sorduğumda kodumu yeniden çalışabilirim.

Tüm gereken LinkedListüzerinde kullanılabilir ArrayListve bunun tersi de?

Özet ArrayList ile ArrayDequede tercih edilir birçok daha kullanım senaryoları LinkedList. Emin değilseniz - sadece başlayın ArrayList.

LinkedListve ArrayListListe arayüzünün iki farklı uygulamasıdır. LinkedListbunu iki bağlantılı bir liste ile uygular.ArrayListdinamik olarak yeniden boyutlandırma dizisiyle uygular.

Standart bağlantılı liste ve dizi işlemlerinde olduğu gibi, çeşitli yöntemler farklı algoritmik çalışma sürelerine sahip olacaktır.

İçin LinkedList<E>

• get(int index)bir O (n) ile ( n / 4 ortalama adımları), ancak O (1) zaman index = 0ya da index = list.size() - 1(bu durumda, aynı zamanda kullanabilir getFirst()ve getLast()). Başlıca faydalarından biri LinkedList<E>
• add(int index, E element)bir O (n) ile ( n / 4 ortalama adımları), ancak O (1) zaman index = 0ya da index = list.size() - 1(bu durumda, aynı zamanda kullanabilir addFirst()ve addLast()/ add()). Başlıca faydalarından biri LinkedList<E>
• remove(int index)bir O (n) ile ( n / 4 ortalama adımları), ancak O (1) zaman index = 0ya da index = list.size() - 1(bu durumda, aynı zamanda kullanabilir removeFirst()ve removeLast()). Başlıca faydalarından biri LinkedList<E>
• Iterator.remove()R , O (1) 'dir . Başlıca faydalarından biri LinkedList<E>
• ListIterator.add(E element)R , O (1) 'dir . Başlıca faydalarından biri LinkedList<E>

^{Not: İşlemlerin çoğunda ortalama olarak n / 4 adım, en iyi durumda sabit adım sayısı (örn. İndex = 0) ve en kötü durumda n / 2 adım (listenin ortasında) gerekir}

İçin ArrayList<E>

• get(int index)R , O (1) 'dir . Ana faydası ArrayList<E>
• add(E element)bir O (1) itfa, ancak O (n) en kötü durum dizi boyutlandırılır ve kopyalanmalıdır yana
• add(int index, E element)bir O (n) ile ( n / 2 ortalama) adımları
• remove(int index)bir O (n) ile ( n / 2 ortalama) adımları
• Iterator.remove()bir O (n) ile ( n / 2 ortalama) adımları
• ListIterator.add(E element)bir O (n) ile ( n / 2 ortalama) adımları

^{Not: İşlemlerin çoğunda ortalama olarak n / 2 adım, en iyi durumda (liste sonu) sabit adım sayısı, en kötü durumda n adım (listenin başlangıcı) gerekir}

LinkedList<E>yineleyiciler kullanılarak sabit zamanlı ekleme veya çıkarma işlemlerine izin verir , ancak öğelere yalnızca sıralı erişim sağlar. Başka bir deyişle, listeyi ileri veya geri yürütebilirsiniz, ancak listede bir konum bulmak listenin boyutuyla orantılı zaman alır. Javadoc, "listeye indeksleyen işlemler listeyi baştan veya sondan, hangisi daha yakınsa seçecektir" diyor , bu nedenle bu yöntemler O (1) için ortalama olarak O (n) ( n / 4 adım) .index = 0

ArrayList<E>Öte yandan, hızlı rastgele okuma erişimine izin verin, böylece herhangi bir öğeyi sabit zamanda yakalayabilirsiniz. Ancak, uçtan başka bir yere ekleme veya çıkarma işlemi, bir açılış yapmak veya boşluğu doldurmak için tüm son elemanların kaydırılmasını gerektirir. Ayrıca altta yatan dizinin kapasitesinden fazla unsurları eklerseniz, yeni bir dizi (1.5 katı büyüklüğünde) tahsis edilir ve eski dizi böylece ekleyerek, yenisine kopyalanır ArrayListolan O (n) en kötü ancak ortalama sabit.

Bu yüzden yapmak istediğiniz işlemlere bağlı olarak, uygulamaları buna göre seçmelisiniz. Her iki Liste üzerinde de yineleme yapmak aynı derecede ucuzdur. (A üzerinde yineleme ArrayListyapmak teknik olarak daha hızlıdır, ancak gerçekten performansa duyarlı bir şey yapmazsanız, bunun için endişelenmemelisiniz - her ikisi de sabittir.)

LinkedListÖğeleri eklemek ve kaldırmak için mevcut yineleyicileri yeniden kullandığınızda ortaya çıkmanın temel faydaları . Bu işlemler daha sonra listeyi yalnızca yerel olarak değiştirerek O (1) ' de yapılabilir . Dizi listesinde, dizinin geri kalanının taşınması (yani kopyalanması) gerekir. Öte yandan, en kötü durum için O (n) ( n / 2 adım) ' LinkedListdaki bağlantıları takip eden bir yöntem arayışındayken , istenen bir pozisyonda matematiksel olarak hesaplanabilir ve O (1)' de erişilebilir .ArrayList

LinkedListListenin başına eklediğinizde veya listenin başından kaldırdığınızda ortaya çıkan bir başka avantaj da, bu işlemler O (1) , O (n) olduğu için ortaya çıkar ArrayList. Baş eklemek ve çıkarmak için ArrayDequeiyi bir alternatif olabileceğini unutmayın LinkedList, ancak a değildir List.

Ayrıca, büyük listeleriniz varsa, bellek kullanımının da farklı olduğunu unutmayın. A öğesinin her öğesi, LinkedListönceki ve sonraki öğelere işaretçiler de depolandığından daha fazla yüke sahiptir. ArrayListsBu yükü yok. Bununla birlikte, ArrayListsöğelerin gerçekten eklenip eklenmediğine bakılmaksızın, kapasite için ayrılan belleği doldurun.

A'nın varsayılan başlangıç ​​kapasitesi ArrayListoldukça küçüktür (Java 1.4 - 1.8'den 10). Ancak temel uygulama bir dizi olduğundan, çok sayıda öğe eklerseniz dizi yeniden boyutlandırılmalıdır. Çok fazla öğe ekleyeceğinizi bildiğinizde yeniden boyutlandırmanın yüksek maliyetinden kaçınmak için, ArrayListdaha yüksek başlangıç ​​kapasitesine sahip bir yapı oluşturun .

Şimdiye kadar, hiç kimse bu listelerin her birinin bellek ayak izini ele alamamış gibi genel fikir birliğinin yanı sıra a'dan LinkedListçok "çok daha fazla" olduğu ArrayListiçin, her iki listenin de N null referanslar için tam olarak ne kadar aldığını göstermek için bir miktar çatırdama yaptım.

Referansları göreli sistemlerinde 32 veya 64 bit (boş olsa bile) olduğundan, 32 ve 64 bit için 4 veri kümesi ekledim LinkedListsve ArrayLists.

Not:ArrayList Çizgiler için gösterilen boyutlar kesilmiş listeler içindir - Uygulamada, bir arka plandaki yedekleme dizisinin kapasitesi ArrayListgenellikle geçerli öğe sayısından daha büyüktür.

Not 2: (teşekkürler BeeOnRope) SıkıştırılmışOp'lar artık JDK6'nın ortasından itibaren ve varsayılan olarak, 64-bit makineler için aşağıdaki değerler, elbette özellikle kapatmazsanız, temel olarak 32-bit eşdeğerleriyle eşleşecektir.

Sonuç , özellikle çok yüksek bir eleman sayımı ile, bunun çok LinkedListdaha fazla olduğunu açıkça göstermektedir ArrayList. Bellek bir faktörse, yönlendirmekten kaçının LinkedLists.

Kullandığım formüller takip ediyor, yanlış bir şey yaptıysam ve düzelteceğimde bana bildirin. 'b' 32 veya 64 bit sistemler için 4 veya 8'dir ve 'n' eleman sayısıdır. Modların nedeninin, java'daki tüm nesnelerin, kullanılmasına bakılmaksızın 8 baytlık katları kaplayacağı için dikkat edin.

ArrayList:

ArrayList object header + size integer + modCount integer + array reference + (array oject header + b * n) + MOD(array oject, 8) + MOD(ArrayList object, 8) == 8 + 4 + 4 + b + (12 + b * n) + MOD(12 + b * n, 8) + MOD(8 + 4 + 4 + b + (12 + b * n) + MOD(12 + b * n, 8), 8)

Bağlantılı liste:

LinkedList object header + size integer + modCount integer + reference to header + reference to footer + (node object overhead + reference to previous element + reference to next element + reference to element) * n) + MOD(node object, 8) * n + MOD(LinkedList object, 8) == 8 + 4 + 4 + 2 * b + (8 + 3 * b) * n + MOD(8 + 3 * b, 8) * n + MOD(8 + 4 + 4 + 2 * b + (8 + 3 * b) * n + MOD(8 + 3 * b, 8) * n, 8)

ArrayLististediğin şey bu. LinkedListneredeyse her zaman bir (performans) hatasıdır.

Neden LinkedListberbat:

• Çok sayıda küçük bellek nesnesi kullanır ve bu nedenle işlem boyunca performansı etkiler.
• Çok sayıda küçük nesne önbellek konumu açısından kötüdür.
• İndekslenmiş herhangi bir işlem bir çapraz geçiş gerektirir, yani O (n) performansına sahiptir. Bu, kaynak kodda belirgin değildir ve O (n) algoritmalarının ArrayListkullanıldığından daha yavaş olmasına neden olur .
• İyi performans elde etmek zordur.
• Big-O performansı ile aynı olsa bile ArrayList, muhtemelen yine de önemli ölçüde daha yavaş olacaktır.
• LinkedListKaynakta görmek zordur çünkü muhtemelen yanlış seçimdir.

Yaklaşık on yıldır çok büyük ölçekli SOA web hizmetlerinde operasyonel performans mühendisliği yapan biri olarak, LinkedList'in ArrayList yerine davranışını tercih ederim. LinkedList'in kararlı durum çıktısı daha kötüdür ve bu nedenle daha fazla donanım satın almanıza neden olabilirken, ArrayList'in baskı altındaki davranışı, bir kümedeki uygulamaların dizilerini neredeyse eşzamanlılıkta ve büyük dizi boyutları için genişletmesine neden olabilir. uygulamada ve bir kesintide, baskı altındayken, bu felaket davranışıdır.

Benzer şekilde, bir uygulamada varsayılan işlem süresi garantili çöp toplayıcıdan daha iyi verim alabilirsiniz, ancak 10 GB yığınları olan java uygulamaları aldığınızda, Tam GC'ler sırasında uygulamayı SOA uygulamalarında zaman aşımlarına ve arızalara neden olan 25 saniye boyunca kilitleyebilirsiniz. ve çok sık meydana gelirse SLA'larınızı üfler. CMS toplayıcı daha fazla kaynak alsa ve aynı ham verimi elde etmese de, daha öngörülebilir ve daha az gecikmeye sahip olduğu için çok daha iyi bir seçimdir.

ArrayList, performans için kast ettiğiniz tek şey iş hacmiyse ve gecikmeyi göz ardı edebiliyorsanız performans için daha iyi bir seçimdir. İşimdeki tecrübelerime göre en kötü durum gecikmesini görmezden gelemem.

Algorithm           ArrayList   LinkedList
seek front            O(1)         O(1)
seek back             O(1)         O(1)
seek to index         O(1)         O(N)
insert at front       O(N)         O(1)
insert at back        O(1)         O(1)
insert after an item  O(N)         O(1)

Algoritmalar: Büyük Oh Gösterimi

ArrayLists, bir kez okunan çok sayıda veya eklenti için iyidir, ancak önden veya ortadan ekleme / çıkarma konusunda kötüdür.

Evet, biliyorum, bu eski bir soru, ama iki sentimi atacağım:

LinkedList neredeyse her zaman yanlış seçimdir, performans açısından. LinkedList'in çağrıldığı bazı çok spesifik algoritmalar vardır, ancak bunlar çok, çok nadirdir ve algoritma genellikle LinkedList'in oraya gittiğinizde listenin ortasındaki öğeleri nispeten hızlı bir şekilde ekleme ve silme yeteneğine bağlı olacaktır. bir ListIterator ile.

LinkedList'in ArrayList'ten daha iyi performans gösterdiği yaygın bir kullanım durumu vardır: bir kuyruğunkinden. Ancak, hedefiniz performanssa, LinkedList yerine ArrayBlockingQueue (sıra boyutunuzda önceden bir üst sınır belirleyebiliyorsanız ve tüm belleği öne atayabilirseniz) veya bu CircularArrayList uygulamasını kullanmayı düşünmelisiniz. . (Evet, 2001'den beri, bunu doğrulamanız gerekecek, ancak kısa bir süre önce yeni bir JVM'de makalede alıntılananlarla karşılaştırılabilir performans oranları aldım)

Bu bir verimlilik sorusu. LinkedListöğeleri eklemek ve silmek için hızlı, ancak belirli bir öğeye erişmek için yavaştır. ArrayListbelirli bir öğeye erişmek için hızlıdır, ancak her iki uca eklemek yavaş olabilir ve özellikle ortada silmek yavaş olabilir.

Array vs ArrayList vs LinkedList vs Vector , Bağlantılı Liste gibi daha derinlemesine ilerliyor .

Doğru veya Yanlış: Lütfen testi yerel olarak yürütün ve kendiniz karar verin!

Düzenleme / Kaldır hızlı olduğundan LinkedListdaha ArrayList.

ArrayList, Arraybüyüklüğünün iki katı olması gereken, büyük hacimli uygulamalarda daha kötüdür.

Aşağıda her bir işlem için birim test sonucu verilmiştir. Zamanlama, Nanosaniye olarak verilmiştir.

Operation                       ArrayList                      LinkedList  

AddAll   (Insert)               101,16719                      2623,29291 

Add      (Insert-Sequentially)  152,46840                      966,62216

Add      (insert-randomly)      36527                          29193

remove   (Delete)               20,56,9095                     20,45,4904

contains (Search)               186,15,704                     189,64,981

İşte kod:

import org.junit.Assert;
import org.junit.Test;

import java.util.*;

public class ArrayListVsLinkedList {
    private static final int MAX = 500000;
    String[] strings = maxArray();

    ////////////// ADD ALL ////////////////////////////////////////
    @Test
    public void arrayListAddAll() {
        Watch watch = new Watch();
        List<String> stringList = Arrays.asList(strings);
        List<String> arrayList = new ArrayList<String>(MAX);

        watch.start();
        arrayList.addAll(stringList);
        watch.totalTime("Array List addAll() = ");//101,16719 Nanoseconds
    }

    @Test
    public void linkedListAddAll() throws Exception {
        Watch watch = new Watch();
        List<String> stringList = Arrays.asList(strings);

        watch.start();
        List<String> linkedList = new LinkedList<String>();
        linkedList.addAll(stringList);
        watch.totalTime("Linked List addAll() = ");  //2623,29291 Nanoseconds
    }

    //Note: ArrayList is 26 time faster here than LinkedList for addAll()

    ///////////////// INSERT /////////////////////////////////////////////
    @Test
    public void arrayListAdd() {
        Watch watch = new Watch();
        List<String> arrayList = new ArrayList<String>(MAX);

        watch.start();
        for (String string : strings)
            arrayList.add(string);
        watch.totalTime("Array List add() = ");//152,46840 Nanoseconds
    }

    @Test
    public void linkedListAdd() {
        Watch watch = new Watch();

        List<String> linkedList = new LinkedList<String>();
        watch.start();
        for (String string : strings)
            linkedList.add(string);
        watch.totalTime("Linked List add() = ");  //966,62216 Nanoseconds
    }

    //Note: ArrayList is 9 times faster than LinkedList for add sequentially

    /////////////////// INSERT IN BETWEEN ///////////////////////////////////////

    @Test
    public void arrayListInsertOne() {
        Watch watch = new Watch();
        List<String> stringList = Arrays.asList(strings);
        List<String> arrayList = new ArrayList<String>(MAX + MAX / 10);
        arrayList.addAll(stringList);

        String insertString0 = getString(true, MAX / 2 + 10);
        String insertString1 = getString(true, MAX / 2 + 20);
        String insertString2 = getString(true, MAX / 2 + 30);
        String insertString3 = getString(true, MAX / 2 + 40);

        watch.start();

        arrayList.add(insertString0);
        arrayList.add(insertString1);
        arrayList.add(insertString2);
        arrayList.add(insertString3);

        watch.totalTime("Array List add() = ");//36527
    }

    @Test
    public void linkedListInsertOne() {
        Watch watch = new Watch();
        List<String> stringList = Arrays.asList(strings);
        List<String> linkedList = new LinkedList<String>();
        linkedList.addAll(stringList);

        String insertString0 = getString(true, MAX / 2 + 10);
        String insertString1 = getString(true, MAX / 2 + 20);
        String insertString2 = getString(true, MAX / 2 + 30);
        String insertString3 = getString(true, MAX / 2 + 40);

        watch.start();

        linkedList.add(insertString0);
        linkedList.add(insertString1);
        linkedList.add(insertString2);
        linkedList.add(insertString3);

        watch.totalTime("Linked List add = ");//29193
    }


    //Note: LinkedList is 3000 nanosecond faster than ArrayList for insert randomly.

    ////////////////// DELETE //////////////////////////////////////////////////////
    @Test
    public void arrayListRemove() throws Exception {
        Watch watch = new Watch();
        List<String> stringList = Arrays.asList(strings);
        List<String> arrayList = new ArrayList<String>(MAX);

        arrayList.addAll(stringList);
        String searchString0 = getString(true, MAX / 2 + 10);
        String searchString1 = getString(true, MAX / 2 + 20);

        watch.start();
        arrayList.remove(searchString0);
        arrayList.remove(searchString1);
        watch.totalTime("Array List remove() = ");//20,56,9095 Nanoseconds
    }

    @Test
    public void linkedListRemove() throws Exception {
        Watch watch = new Watch();
        List<String> linkedList = new LinkedList<String>();
        linkedList.addAll(Arrays.asList(strings));

        String searchString0 = getString(true, MAX / 2 + 10);
        String searchString1 = getString(true, MAX / 2 + 20);

        watch.start();
        linkedList.remove(searchString0);
        linkedList.remove(searchString1);
        watch.totalTime("Linked List remove = ");//20,45,4904 Nanoseconds
    }

    //Note: LinkedList is 10 millisecond faster than ArrayList while removing item.

    ///////////////////// SEARCH ///////////////////////////////////////////
    @Test
    public void arrayListSearch() throws Exception {
        Watch watch = new Watch();
        List<String> stringList = Arrays.asList(strings);
        List<String> arrayList = new ArrayList<String>(MAX);

        arrayList.addAll(stringList);
        String searchString0 = getString(true, MAX / 2 + 10);
        String searchString1 = getString(true, MAX / 2 + 20);

        watch.start();
        arrayList.contains(searchString0);
        arrayList.contains(searchString1);
        watch.totalTime("Array List addAll() time = ");//186,15,704
    }

    @Test
    public void linkedListSearch() throws Exception {
        Watch watch = new Watch();
        List<String> linkedList = new LinkedList<String>();
        linkedList.addAll(Arrays.asList(strings));

        String searchString0 = getString(true, MAX / 2 + 10);
        String searchString1 = getString(true, MAX / 2 + 20);

        watch.start();
        linkedList.contains(searchString0);
        linkedList.contains(searchString1);
        watch.totalTime("Linked List addAll() time = ");//189,64,981
    }

    //Note: Linked List is 500 Milliseconds faster than ArrayList

    class Watch {
        private long startTime;
        private long endTime;

        public void start() {
            startTime = System.nanoTime();
        }

        private void stop() {
            endTime = System.nanoTime();
        }

        public void totalTime(String s) {
            stop();
            System.out.println(s + (endTime - startTime));
        }
    }


    private String[] maxArray() {
        String[] strings = new String[MAX];
        Boolean result = Boolean.TRUE;
        for (int i = 0; i < MAX; i++) {
            strings[i] = getString(result, i);
            result = !result;
        }
        return strings;
    }

    private String getString(Boolean result, int i) {
        return String.valueOf(result) + i + String.valueOf(!result);
    }
}

ArrayListaslında bir dizidir. LinkedListçift ​​bağlantılı bir liste olarak uygulanır.

getOldukça açıktır. O (1) için ArrayList, çünkü ArrayListindeks kullanarak rastgele erişime izin verin. O (n) için LinkedList, çünkü önce dizini bulması gerekir. Not: farklı sürümleri vardır addve remove.

LinkedListekleme ve kaldırmada daha hızlı, ancak almada daha yavaştır. Kısaca, aşağıdaki LinkedListdurumlarda tercih edilmelidir:

1. çok sayıda rastgele eleman erişimi yok
2. çok sayıda ekleme / çıkarma işlemi var

=== ArrayList ===

• ekle (E e)
  • ArrayList'in sonuna ekle
  • bellek yeniden boyutlandırma maliyeti gerektirir.
  • O (n) en kötü, O (1) itfa edilmiş
• ekle (int dizini, E öğesi)
  • belirli bir dizin konumuna ekle
  • kaydırma ve olası bellek yeniden boyutlandırma maliyeti gerektirir
  • O (n)
• kaldır (int dizini)
  • belirtilen bir öğeyi kaldır
  • kaydırma ve olası bellek yeniden boyutlandırma maliyeti gerektirir
  • O (n)
• kaldır (Object o)
  • belirtilen öğenin ilk oluşumunu bu listeden kaldır
  • önce öğeyi aramak ve daha sonra olası bellek yeniden boyutlandırma maliyetini değiştirmek gerekir
  • O (n)

=== LinkedList ===

• ekle (E e)

  • listenin sonuna ekle
  • O (1)

• ekle (int dizini, E öğesi)

  • belirtilen konumda takın
  • önce pozisyonu bulmalıyım
  • O (n)
• Kaldırmak()
  • listenin ilk öğesini kaldır
  • O (1)
• kaldır (int dizini)
  • belirtilen dizine sahip öğeyi kaldır
  • önce elemanı bulmalısın
  • O (n)
• kaldır (Object o)
  • belirtilen öğenin ilk oluşumunu kaldır
  • önce elemanı bulmalısın
  • O (n)

Burada programcreek.com adresinden bir rakam bulunmaktadır ( addve removeilk türdür, yani listenin sonuna bir öğe ekleyin ve öğeyi listede belirtilen konumda kaldırın.):

LinkedList'in yazarı Joshua Bloch:

LinkedList'i gerçekten kullanan var mı? Ben yazdım ve hiç kullanmadım.

Bağlantı: https://twitter.com/joshbloch/status/583813919019573248

Diğer cevaplar kadar bilgilendirici olmadığı için cevap için üzgünüm, ama bunun en ilginç ve açıklayıcı olacağını düşündüm.

ArrayListrastgele erişilebilir, ancak LinkedListöğeleri genişletmek ve kaldırmak için gerçekten ucuz. Çoğu durumda, ArrayListiyidir.

Büyük listeler oluşturmadıysanız ve bir darboğaz ölçmediyseniz, muhtemelen fark hakkında endişelenmenize gerek kalmayacak.

TL; Modern bilgisayar mimarisi nedeniyle DR , ArrayListneredeyse tüm olası kullanım durumları için önemli ölçüde daha verimli olacaktır ve bu nedenle LinkedListbazı benzersiz ve aşırı durumlar dışında kaçınılmalıdır.

Teorik olarak, LinkedList için O (1) add(E element)

Ayrıca listenin ortasına bir öğe eklemek çok verimli olmalıdır.

LinkedList bir Cache Hostile Data yapısı olduğu için uygulama çok farklıdır . Performans POV'sinden - Önbellek dostuLinkedList olmaktan daha iyi performans gösterebilecek çok az durum vardır . ArrayList

Rastgele konumlardaki eleman ekleme testlerinin sonuçları aşağıda verilmiştir. Gördüğünüz gibi - çok daha verimli ise dizi listesi, ancak teoride listenin ortasındaki her ekleme dizinin n sonraki öğelerini "taşımak" gerektirir (daha düşük değerler daha iyidir):

Yeni nesil bir donanım üzerinde çalışmak (daha büyük, daha verimli önbellekler) - sonuçlar daha da kesin:

LinkedList aynı işi yapmak için çok daha fazla zaman alır. kaynak Kaynak Kodu

Bunun iki ana nedeni vardır:

1. Temel olarak - düğümlerinin LinkedListbellek boyunca rastgele dağılmasıdır. RAM ("Rasgele Erişim Belleği") gerçekten rastgele değildir ve önbellek için bellek bloklarının getirilmesi gerekir. Bu işlem zaman alır ve bu tür getirmeler sık ​​sık gerçekleştiğinde - önbellekteki bellek sayfalarının her zaman değiştirilmesi gerekir -> Önbellek özlüyor -> Önbellek verimli değildir. ArrayListöğeler sürekli bellekte depolanır - bu modern CPU mimarisinin tam olarak ne için optimizasyon yaptığıdır.

2. İkincil LinkedList işaretçileri geri / ileri tutmak için gereklidir, bu da depolanan değer başına 3 kat daha fazla bellek tüketimi anlamına gelir ArrayList.

DynamicIntArray , btw, IntNesneler değil , özel bir ArrayList uygulama tutucusudur (ilkel tip) - dolayısıyla tüm veriler gerçekten bitişik olarak saklanır - dolayısıyla daha da verimli olur.

Hatırlanması gereken önemli bir unsur, bellek bloğunu getirmenin maliyetinin, tek bir bellek hücresine erişim maliyetinden daha önemli olmasıdır. Bu yüzden okuyucu 1MB sıralı bellek, farklı bellek bloklarından bu miktarda veri okumaktan x400 kat daha hızlıdır:

Latency Comparison Numbers (~2012)
----------------------------------
L1 cache reference                           0.5 ns
Branch mispredict                            5   ns
L2 cache reference                           7   ns                      14x L1 cache
Mutex lock/unlock                           25   ns
Main memory reference                      100   ns                      20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy             3,000   ns        3 us
Send 1K bytes over 1 Gbps network       10,000   ns       10 us
Read 4K randomly from SSD*             150,000   ns      150 us          ~1GB/sec SSD
Read 1 MB sequentially from memory     250,000   ns      250 us
Round trip within same datacenter      500,000   ns      500 us
Read 1 MB sequentially from SSD*     1,000,000   ns    1,000 us    1 ms  ~1GB/sec SSD, 4X memory
Disk seek                           10,000,000   ns   10,000 us   10 ms  20x datacenter roundtrip
Read 1 MB sequentially from disk    20,000,000   ns   20,000 us   20 ms  80x memory, 20X SSD
Send packet CA->Netherlands->CA    150,000,000   ns  150,000 us  150 ms

Kaynak: Her Programcının Bilmesi Gereken Gecikme Sayıları

Sadece noktayı daha da netleştirmek için lütfen listenin başına öğe ekleme ölçütünü kontrol edin. Bu, teorik olarak, LinkedListgerçekten parlaması ArrayListgereken ve kötü veya daha kötü durumda sonuçlar sunması gereken bir kullanım durumudur:

Not: Bu, C ++ Std lib'in bir ölçütüdür, ancak önceki deneyimim C ++ ve Java sonuçlarının çok benzer olduğunu gösterdi. Kaynak kodu

Sıralı bir bellek yığınını kopyalamak, modern CPU'lar tarafından optimize edilmiş bir işlemdir - teoriyi değiştirmek ve aslında tekrar ArrayList/ Vectorçok daha verimli hale getirmek

Kredi: Burada yayınlanan tüm kriterler Kjell Hedström tarafından oluşturulur . Daha da veri bulunabilir blogunda

Kodunuzda add(0)ve varsa remove(0), bir LinkedListve daha güzel addFirst()ve removeFirst()yöntemler kullanın. Aksi takdirde kullanın ArrayList.

Ve tabii ki, Guava 'in ImmutableList en iyi arkadaşınızdır.

Bunun eski bir yazı olduğunu biliyorum, ama dürüstçe kimsenin LinkedListuyguladığından bahsetmediğine inanamıyorum Deque. Sadece Deque(ve Queue) ' deki yöntemlere bakın ; Adil bir karşılaştırma yapmak istiyorsanız, LinkedListkarşı çalışmayı deneyin ArrayDequeve özellik için bir karşılaştırma yapın.

İşte hem Big-O gösterimi olan ArrayListve LinkedListayrıca CopyOnWrite-ArrayList:

ArrayList

get                 O(1)
add                 O(1)
contains            O(n)
next                O(1)
remove              O(n)
iterator.remove     O(n)

Bağlantılı liste

get                 O(n)
add                 O(1)
contains            O(n)
next                O(1)
remove              O(1)
iterator.remove     O(1)

CopyOnWrite-ArrayList

get                 O(1)
add                 O(n)
contains            O(n)
next                O(1)
remove              O(n)
iterator.remove     O(n)

Bunlara dayanarak ne seçeceğinize karar vermelisiniz. :)

LinkedList ve ArrayList wrt parametrelerini aşağıdaki ile karşılaştıralım:

1. Uygulama

ArrayList , liste arayüzünün yeniden boyutlandırılabilir dizi uygulamasıdır.

LinkedList , liste arayüzünün Çift Bağlantılı liste uygulamasıdır.

2. Performans

• get (int dizini) veya arama işlemi

  ArrayList get (int dizini) işlemi sabit zamanda çalışır, yani O (1)

  Bağlantılı liste get (int dizini) işlemi çalışma süresi O (n) 'dir.

  ArrayList'in arkasındaki neden LinkedList'ten daha hızlı olmasının , ArrayList'in dahili olarak bir dizi veri yapısı kullandığı için elemanları için dizin tabanlı bir sistem kullanmasıdır.

  LinkedList , belirtilen öğe dizinindeki düğümü almak için başlangıçtan veya sondan (hangisi daha yakınsa) yinelediğinden, öğeleri için dizin tabanlı erişim sağlamaz.

• insert () veya add (Object) işlemi

  LinkedList'deki eklemeler genellikle ArrayList ile karşılaştırıldığında hızlıdır. LinkedList'te ekleme veya ekleme O (1) işlemidir.

  ArrayList'te iken , dizi tam yani en kötü durumda ise, dizi yeniden boyutlandırma ve öğeleri yeni diziye kopyalamanın ek bir maliyeti vardır, bu da ArrayList O (n) 'de ekleme işleminin çalışma zamanını yapar, aksi takdirde O (1) .

• kaldır (int) işlemi

  LinkedList'teki kaldırma işlemi genellikle ArrayList yani O (n) ile aynıdır.

  In LinkedList , iki Aşırı yüklü kaldır yöntemi vardır. birincisi, listenin başlığını kaldıran ve sabit zaman O (1) ile çalışan herhangi bir parametre olmadan remove () 'dir. LinkedList'teki diğer aşırı yüklenmiş kaldırma yöntemi, parametre olarak iletilen Object veya int'i kaldıran remove (int) veya remove (Object) yöntemidir. Bu yöntem, Object'i bulana ve orijinal listeden bağlantısını kaldırana kadar LinkedList'i dolaşır. Bu nedenle, bu yöntem çalışma zamanı O (n) 'dir.

  İken ArrayList'in remove (int) yöntemi, yeni güncellenmiş bir dizi eski diziden elemanları kopyalama içeren bu nedenle çalışma zamanı O (n) 'dir.

3. Ters Yineleyici

LinkedList , descendingIterator () kullanılarak ters yönde yinelenebilir

ArrayList'te descendingIterator () yoktur , bu nedenle ArrayList'i ters yönde yinelemek için kendi kodumuzu yazmamız gerekir.

4. Başlangıç ​​Kapasitesi

Yapıcı aşırı yüklenmemişse, ArrayList başlangıç ​​kapasitesi 10'un boş bir listesini oluştururken,

LinkedList boş listeyi yalnızca başlangıç ​​kapasitesi olmadan oluşturur.

5. Bellek Yükü

LinkedList'te bellek ek yükü ArrayList ile karşılaştırıldığında daha fazladır, çünkü bir düğümün sonraki ve önceki düğümün adreslerini tutması gerekir. Süre

Gelen ArrayList her dizin sadece gerçek nesne (veri) tutar.

Kaynak

Bu Listede gerçekleştirdiğim işlemlerin zaman karmaşıklıklarına dayanarak genellikle diğerini kullanıyorum.

|---------------------|---------------------|--------------------|------------|
|      Operation      |     ArrayList       |     LinkedList     |   Winner   |
|---------------------|---------------------|--------------------|------------|
|     get(index)      |       O(1)          |         O(n)       | ArrayList  |
|                     |                     |  n/4 steps in avg  |            |
|---------------------|---------------------|--------------------|------------|
|      add(E)         |       O(1)          |         O(1)       | LinkedList |
|                     |---------------------|--------------------|            |
|                     | O(n) in worst case  |                    |            |
|---------------------|---------------------|--------------------|------------|
|    add(index, E)    |       O(n)          |         O(n)       | LinkedList |
|                     |     n/2 steps       |      n/4 steps     |            |
|                     |---------------------|--------------------|            |
|                     |                     |  O(1) if index = 0 |            |
|---------------------|---------------------|--------------------|------------|
|  remove(index, E)   |       O(n)          |         O(n)       | LinkedList |
|                     |---------------------|--------------------|            |
|                     |     n/2 steps       |      n/4 steps     |            |
|---------------------|---------------------|--------------------|------------|
|  Iterator.remove()  |       O(n)          |         O(1)       | LinkedList |
|  ListIterator.add() |                     |                    |            |
|---------------------|---------------------|--------------------|------------|


|--------------------------------------|-----------------------------------|
|              ArrayList               |            LinkedList             |
|--------------------------------------|-----------------------------------|
|     Allows fast read access          |   Retrieving element takes O(n)   |
|--------------------------------------|-----------------------------------|
|   Adding an element require shifting | o(1) [but traversing takes time]  |
|       all the later elements         |                                   |
|--------------------------------------|-----------------------------------|
|   To add more elements than capacity |
|    new array need to be allocated    |
|--------------------------------------|

Yukarıdaki diğer iyi argümanlar ek olarak, fark etmelidir ArrayListuygular RandomAccessederken, arayüz LinkedListuygular Queue.

Böylece, bir şekilde verimlilik ve davranış farkı ile biraz farklı problemleri ele alıyorlar (bkz. Yöntem listesi).

Bu, Listede daha fazla hangi işlemleri yapacağınıza bağlıdır.

ArrayListdizinlenmiş bir değere erişmek daha hızlıdır. Nesneleri eklerken veya silerken çok daha kötüdür.

Daha fazla bilgi edinmek için, diziler ve bağlantılı listeler arasındaki farktan söz eden makaleleri okuyun.

Dizi listesi temelde öğe vb. Ekleme yöntemlerine sahip bir dizidir (ve bunun yerine genel bir liste kullanmalısınız). Bir indeksleyici ile erişilebilen bir öğeler topluluğudur (örneğin [0]). Bir öğeden diğerine ilerleme anlamına gelir.

Bağlantılı liste, bir öğeden diğerine ilerlemeyi belirtir (Madde a -> madde b). Bir dizi listesiyle aynı efekti elde edebilirsiniz, ancak bağlantılı bir liste kesinlikle hangi öğenin öncekini izlemesi gerektiğini söyler.

Bkz . Java Eğiticileri - Liste Uygulamaları .

Bağlantılı bir listenin önemli bir özelliği (başka bir cevapta okumadım) iki listenin birleştirilmesidir. Bir dizi ile bu bağlantılı bir liste ile O (n) (+ bazı yeniden tahsislerin yükü) bu sadece O (1) veya O (2) ;-)

Önemli : Java için LinkedListbu doğru değildir! Bkz Java bağlantılı liste için hızlı bir concat yöntem var mı?

ArrayList ve LinkedList'in kendi artıları ve eksileri vardır.

ArrayList, bir sonraki düğüme doğru işaretçiler kullanan LinkedList ile karşılaştırıldığında bitişik bellek adresi kullanır. Dolayısıyla, bir ArrayList öğesinde bir öğeyi aramak istediğinizde LinkedList ile n yineleme yapmaktan daha hızlıdır.

Öte yandan, bir LinkedList'e ekleme ve silme çok daha kolaydır, çünkü sadece işaretçileri değiştirmeniz gerekir, oysa ArrayList herhangi bir ekleme veya silme için kaydırma işlemi kullanımını gerektirir.

Uygulamanızda sık sık alım işlemleriniz varsa bir ArrayList kullanın. Sık ekleme ve silme işlemleriniz varsa LinkedList kullanın.

Yanıtları okudum, ancak her zaman bir ArrayList üzerinde fikirleri duymak için paylaşmak istediğim bir LinkedList kullandığım bir senaryo var:

Her zaman bir DB elde edilen veri listesini döndüren bir yöntem vardı her zaman bir LinkedList kullanın.

Benim mantığım, tam olarak kaç sonuç aldığımı bilmek imkansız olduğu için, bellek israfı olmayacak (ArrayList'te kapasite ve gerçek eleman sayısı arasındaki farkla olduğu gibi) olacak ve kapasiteyi çoğaltın.

Bir ArrayList'e göre, dizilerin çoğalmasını mümkün olduğunca en aza indirmek için en azından yapıcıyı her zaman başlangıç ​​kapasitesiyle kullanmanız gerektiğini kabul ediyorum.

ArrayListve LinkedListhem uygulamalar List interface hem de yöntemleri ve sonuçları neredeyse aynıdır. Bununla birlikte, aralarında ihtiyaca bağlı olarak birini diğerinden daha iyi yapan birkaç fark vardır.

ArrayList vs LinkedList

1) Search: ArrayListarama işlemi, arama işlemine kıyasla oldukça hızlıdır LinkedList. get(int index)içinde ArrayListperformansını verir O(1)iken LinkedListperformanstır O(n).

Reason: ArrayListdizideki veri yapısını dolaylı olarak kullandığı için listedeki bir öğenin aranmasını daha hızlı hale getiren, dizin tabanlı sistemi öğeler için tutar. Diğer taraftaLinkedList , bir eleman aramak için tüm elemanlar arasında geçiş yapılmasını gerektiren çift bağlantılı bir liste uygular.

2) Deletion: LinkedListkaldırma işlemi değişken O(1)performans verirken performans ArrayListverir: O(n)en kötü durumda (ilk elemanı çıkarırken) ve O(1)en iyi durumda (son elemanı çıkarırken).

Sonuç: LinkedList öğesinin silinmesi ArrayList'e göre daha hızlıdır.

Sebep: LinkedList'in her öğesi, listedeki her iki komşu öğeye işaret eden iki işaretçi (adres) tutar. Bu nedenle, kaldırma işlemi yalnızca, kaldırılacak düğümün iki komşu düğümünde (öğelerinde) işaretçi konumunda değişiklik gerektirir. ArrayList öğesindeyken, kaldırılan öğenin oluşturduğu alanı doldurmak için tüm öğelerin kaydırılması gerekir.

3) Inserts Performance: LinkedListekleme yöntemi O(1)performans verirken en kötü durumda ArrayListverir O(n). Nedeni, kaldırılması için açıklananla aynıdır.

4) eleman verilerini ve komşu düğümler için iki işaretçi Memory Overhead: ArrayListtutarken indeksleri ve eleman verilerini LinkedListkorur

bu nedenle LinkedList'te bellek tüketimi nispeten yüksektir.

Bu sınıflar arasında aşağıdaki gibi birkaç benzerlik vardır:

• Hem ArrayList hem de LinkedList, Liste arabiriminin uygulanmasıdır.
• Her ikisi de eleman ekleme sırasını korur, yani ArrayList ve LinkedList öğelerini görüntülerken, sonuç kümesi öğelerin Listeye eklendiği sıraya sahip olur.
• Bu sınıfların her ikisi de senkronize değildir ve Collections.synchronizedList yöntemi kullanılarak açıkça senkronize edilebilir.
• iteratorVe listIteratorbu sınıfların tarafından döndürülen olan fail-fast(liste yapısal yineleyici oluşturulduktan sonra kullanma dışında herhangi bir şekilde, herhangi bir zamanda değiştirilirse iterator’skendi kaldır veya ekleme yöntemleri, yineleyici olacak throwbir ConcurrentModificationException).

LinkedList ne zaman ve ArrayList ne zaman kullanılır?

• İnsert ve kaldır operasyonlar Yukarıda açıklandığı gibi iyi bir performans vermek (O(1))içinde LinkedListkarşılaştırıldığındaArrayList(O(n)) .

  Bu nedenle, uygulamada sık sık ekleme ve silme gereksinimi varsa LinkedList en iyi seçimdir.

• Search ( get method) işlemleri hızlı, Arraylist (O(1))ancak değilLinkedList (O(n))

  bu nedenle, daha az ekleme ve kaldırma işlemi ve daha fazla arama işlemi gereksinimi varsa, ArrayList sizin için en iyi seçenektir.

ArrayList içindeki get (i) işlemi LinkedList'ten daha hızlıdır, çünkü:
ArrayList: LinkedList Liste arayüzünün yeniden boyutlandırılabilir dizi uygulaması
: boyutlandırılabilir List ve Deque arabirimlerinin çift bağlantılı listesi uygulaması

Listede dizin oluşturan işlemler, belirtilen dizine hangisi daha yakınsa listeyi baştan veya sondan itibaren değiştirir.

1) Temel Veri Yapısı

ArrayList ve LinkedList arasındaki ilk fark, ArrayList'in Array tarafından desteklenirken, LinkedList LinkedList tarafından desteklenir. Bu, performansta daha fazla farklılığa yol açacaktır.

2) LinkedList Deque uygular

ArrayList ve LinkedList arasındaki bir diğer fark, LinkedList, List arabirimi dışında, add () ve poll () ve diğer birkaç Deque işlevi için ilk giren ilk işlemleri sağlayan Deque arabirimini de uygular. 3) ArrayList öğelerine öğe ekleme ArrayList öğesinde öğe ekleme, Array öğesinin yeniden boyutunu tetiklemezse O (1) işlemidir, bu durumda O (log (n)) olur, Öte yandan, LinkedList, herhangi bir navigasyon gerektirmediği için O (1) işlemidir.

4) Bir elemanın bir konumdan çıkarılması

Belirli bir dizinden bir öğeyi kaldırmak için örneğin remove (index) öğesini çağırmak üzere, ArrayList, O (n) 'ye yakın hale getiren bir kopyalama işlemi gerçekleştirirken, LinkedList'in de O (n / 2) yapan o noktaya geçmesi gerekir. , yakınlığa dayalı olarak her iki yönden de hareket edebildiği için.

5) ArrayList veya LinkedList üzerinden yineleme

Yineleme, LinkedList ve ArrayList için O (n) işlemidir; burada n, bir dizi öğedir.

6) Elemanın bir konumdan alınması

Get (index) işlemi ArrayList'te O (1) iken LinkedList'teki O (n / 2), bu girişe kadar geçiş yapması gerekir. Yine de, Büyük O gösterimlerinde O (n / 2) sadece O (n) 'dir çünkü orada sabitleri görmezden geliriz.

7) Bellek

LinkedList, veriyi saklamak için statik iç içe bir sınıf ve sonraki ve önceki iki düğüm olan bir sargı nesnesi olan Entry'yi kullanırken ArrayList, verileri yalnızca Array'da depolar.

Bu nedenle, ArrayList durumunda ArrayList söz konusu olduğunda, Array öğesinin içeriği bir Array öğesinden diğerine kopyalarken yeniden boyutlandırma işlemini gerçekleştirmesi durumu haricinde, bellek gereksinimi LinkedList'ten daha az görünür.

Dizi yeterince büyükse, bu noktada çok fazla bellek alabilir ve Çöp toplamayı tetikleyebilir, bu da yanıt süresini yavaşlatabilir.

ArrayList ile LinkedList arasındaki yukarıdaki tüm farklardan, ArrayList, remove () veya get () 'den daha sık bir add () işlemi yapmanız dışında hemen hemen tüm durumlarda LinkedList'ten daha iyi bir seçimdir.

Bağlantılı listeyi ArrayList'e göre değiştirmek daha kolaydır, özellikle de bağlantılı listeyi başlangıç ​​veya bitişten ekliyorsanız veya kaldırıyorsanız, bağlantılı liste dahili olarak bu konumların referanslarını tutar ve bunlara O (1) zamanda erişilebilir.

Başka bir deyişle, eleman eklemek istediğiniz konuma ulaşmak için bağlantılı listede gezinmenize gerek yoktur, bu durumda ekleme O (n) işlemi haline gelir. Örneğin, bağlı listenin ortasına bir öğe ekleme veya silme.

Bence Java'daki pratik amaçların çoğu için LinkedList üzerinden ArrayList kullanın.

Burada gördüğüm testlerden biri testi sadece bir kez yapıyor. Ama farkettim ki, bu testleri birçok kez çalıştırmanız gerekiyor ve sonunda zamanları birleşecek. Temel olarak JVM'nin ısınması gerekir. Özel kullanım durumum için, yaklaşık 500 öğeye kadar büyüyen bir listeye öğe eklemem / kaldırmam gerekiyordu. Testlerim LinkedListdaha hızlı çıktı, LinkedListyaklaşık 50.000 NS ArrayListgeliyor ve yaklaşık 90.000 NS geliyor ... ver ya da al. Aşağıdaki koda bakınız.

public static void main(String[] args) {
    List<Long> times = new ArrayList<>();
    for (int i = 0; i < 100; i++) {
        times.add(doIt());
    }
    System.out.println("avg = " + (times.stream().mapToLong(x -> x).average()));
}

static long doIt() {
    long start = System.nanoTime();
    List<Object> list = new LinkedList<>();
    //uncomment line below to test with ArrayList
    //list = new ArrayList<>();
    for (int i = 0; i < 500; i++) {
        list.add(i);
    }

    Iterator it = list.iterator();
    while (it.hasNext()) {
        it.next();
        it.remove();
    }
    long end = System.nanoTime();
    long diff = end - start;
    //uncomment to see the JVM warmup and get faster for the first few iterations
    //System.out.println(diff)
    return diff;
}

Remove () ve insert () öğelerinin hem ArrayLists hem de LinkedLists için O (n) çalışma zamanı verimliliği vardır. Bununla birlikte, doğrusal işlem süresinin arkasındaki neden çok farklı iki nedenden kaynaklanmaktadır:

Bir ArrayList'te O (1) öğesindeki öğeye ulaşırsınız, ancak aslında bir şeyin kaldırılması veya eklenmesi onu aşağıdaki öğelerin O (n) yapar çünkü aşağıdaki tüm öğelerin değiştirilmesi gerekir.

LinkedList'te, istenen öğeye ulaşmak O (n) gerektirir, çünkü istenen dizine ulaşana kadar en baştan başlamalıyız. Aslında kaldırma veya ekleme sabittir, çünkü remove () için yalnızca 1 referansı ve insert () için 2 referansını değiştirmemiz gerekir.

İkisinin hangisi ekleme ve çıkarma için daha hızlı olduğu, nerede olduğuna bağlıdır. Eğer başlangıca yaklaşırsak LinkedList daha hızlı olacaktır, çünkü nispeten az sayıda öğeden geçmemiz gerekir. Eğer sona yaklaşırsak, bir ArrayList daha hızlı olacaktır, çünkü oraya sabit zamanda ulaşırız ve sadece onu takip eden kalan birkaç öğeyi değiştirmeliyiz. Tam olarak ortada yapıldığında LinkedList daha hızlı olacaktır çünkü n öğesinden geçmek n değerlerini taşımaktan daha hızlıdır.

Bonus: Bir ArrayList için bu iki yöntemi O (1) yapmanın bir yolu olmasa da, aslında LinkedLists'te bunu yapmanın bir yolu vardır. Diyelim ki yolumuzdaki öğeleri kaldırarak ve ekleyerek tüm Listeyi gözden geçirmek istiyoruz. Genellikle, LinkedList'i kullanarak her öğe için en baştan başlarsınız, aynı zamanda bir Yineleyici ile üzerinde çalıştığımız mevcut öğeyi "kaydedebiliriz". Yineleyicinin yardımıyla, LinkedList'te çalışırken remove () ve insert () için O (1) verimliliği elde ederiz. Bir LinkedList'in her zaman bir ArrayList'ten daha iyi olduğunun farkında olduğum tek performans avantajı yapmak.

ArrayList, AbstractList'i genişletir ve Liste Arayüzünü uygular. ArrayList dinamik dizidir.
Temel olarak dizilerin dezavantajlarının üstesinden gelmek için oluşturulduğu söylenebilir

LinkedList sınıfı AbstractSequentialList'i genişletir ve List, Deque ve Queue arabirimini uygular.
Performans
arraylist.get()O (1) iken linkedlist.get()O (n)
arraylist.add()O (1) ve linkedlist.add()0 (1)
arraylist.contains()O (n) ve linkedlist.contains()O (n)
arraylist.next()O (1) ve linkedlist.next()O (1)
arraylist.remove()O (n) 'dir oysa linkedlist.remove()O (1) olup
ArrayList
iterator.remove()O (n)
olarak LinkedList ise
iterator.remove()O'dur (1)