LinkedList Java'da ArrayList ├╝zerinden ne zaman kullan─▒l─▒r?


Al─▒nan cevaba git


Ben her zaman basit├že kullanacak biri oldum:

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

Arabirimi ta┼č─▒nabilirlik i├žin t├╝r ad─▒ olarak kullan─▒yorum , b├Âylece bunlar gibi sorular sordu─čumda kodumu yeniden ├žal─▒┼čt─▒rabilirim.

Ne zaman ve ne LinkedList zaman kullan─▒lmal─▒ ArrayList ?


2945









Cevap say─▒s─▒n─▒ say: 30






├ľzet ArrayList ile ArrayDeque de tercih edilir bir├žok daha kullan─▒m senaryolar─▒ LinkedList . Emin de─čilseniz - sadece ba┼čla ArrayList .


LinkedList ve ArrayList Liste aray├╝z├╝n├╝n iki farkl─▒ uygulamas─▒d─▒r. LinkedList iki kat ba─člant─▒l─▒ bir liste ile uygular. ArrayList dinamik 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─▒
  • add(E element) bir O (1)
  • add(int index, E element) bir O (n) ile ( n / 4 , ancak ortalama ad─▒mlar─▒) O (1) index = 0 aras─▒nda <--- temel faydas─▒ LinkedList<E>
  • remove(int index) bir O (n) ile ( n / 4 ortalama) ad─▒mlar─▒
  • Iterator.remove() bir O (1) . <--- ana paras─▒ LinkedList<E>
  • ListIterator.add(E element) bir O (1) bu ana avantajlar─▒ndan biri olan LinkedList<E>

Not: Operasyonlar─▒n bir├žo─čunun ortalama 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─▒) gerekir

─░├žin ArrayList<E>

  • get(int index) bir O (1) aras─▒nda <--- temel 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: operasyonlar─▒n bir├žo─ču gerek / n 2 ortalama, ad─▒mlar─▒ s├╝rekli iyi durumda ad─▒mlar (listenin sonunda) say─▒s─▒, n en k├Ât├╝ durumda ad─▒mlar (listenin ba┼člang─▒├ž)

LinkedList<E> Sabit zamanl─▒ ekleme veya yineleme kullanan kald─▒rmaya izin verir , ancak ├Â─čelere yaln─▒zca s─▒ral─▒ eri┼čim sa─člar. Ba┼čka bir deyi┼čle, listeyi ileri ya da geri g├Ât├╝rebilirsiniz, ancak listede bir konum bulmak listenin boyutuyla orant─▒l─▒ olarak zaman al─▒r. Javadoc diyor "listesine endeksi yak─▒n hangisi ba┼č─▒nda veya sonunda, gelen listesinde ge├ži┼č olaca─č─▒ operasyonlar─▒" y├Ântemleri kapsar; b├Âylece, O (n) ( n / 4 ra─čmen, ortalama ad─▒m) O (1) i├žin index = 0 .

ArrayList<E> ├ľte yandan, h─▒zl─▒ rasgele okuma eri┼čimine izin verin, b├Âylece herhangi bir ├Â─čeyi sabit bir s├╝rede yakalayabilirsiniz. Ancak herhangi bir yerden ekleme veya ├ž─▒karma ancak son, bir a├ž─▒l─▒┼č yapmak veya bo┼člu─ču doldurmak i├žin t├╝m sonraki ├Â─čelerin 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 ArrayList olan O (n) en k├Ât├╝ durumda ama ortalama olarak sabit.

Bu nedenle, yapmak istedi─činiz i┼člemlere ba─čl─▒ olarak, uygulamalar─▒ buna g├Âre se├žmelisiniz. Her iki t├╝r Liste ├╝zerinde yineleme yapmak neredeyse e┼čit derecede ucuz. (├ťzerinde yineleme ArrayList yapmak teknik olarak daha h─▒zl─▒d─▒r, ancak performansa duyarl─▒ bir ┼čey yapm─▒yorsan─▒z, bu konuda endi┼čelenmemelisiniz - ikisi de sabittir.)

LinkedList ├ľ─čeleri eklemek ve kald─▒rmak i├žin varolan yineleyicileri yeniden kulland─▒─č─▒n─▒zda ortaya ├ž─▒kman─▒n ba┼čl─▒ca faydalar─▒ . Bu i┼člemler daha sonra yaln─▒zca yerel olarak listeyi de─či┼čtirerek O (1) ' de yap─▒labilir . Bir dizi listesinde, dizinin geri kalan─▒n─▒n ta┼č─▒nmas─▒ gerekir (yani kopyalan─▒r). Di─čer taraftan, en k├Ât├╝ durum i├žin O (n) 'deki ( n / 2 ad─▒mdaki) LinkedList ba─člant─▒lar─▒ izleyen bir yol aramak , ancak istenen bir pozisyonda matematiksel olarak hesaplanabilir ve O (1)' e eri┼čilebilir . ArrayList

Bir kullanman─▒n bir di─čer yarar─▒ LinkedList listenin ba┼č─▒ndan eklemek veya kald─▒r zaman bu operasyonlar oldu─čundan, ortaya O (1) onlar olsa da, O (n) i├žin ArrayList . Ba┼ča ekleme ve ├ž─▒karma i┼člemlerine ArrayDeque iyi bir alternatif olabilece─čini unutmay─▒n LinkedList , ancak bu bir de─čildir List .

Ayr─▒ca, b├╝y├╝k listeleriniz varsa, bellek kullan─▒m─▒n─▒n da farkl─▒ oldu─čunu unutmay─▒n. Bir LinkedList ├Ânceki ve sonraki elementlere i┼čaret├žiler de kaydedildi─činden, her bir eleman─▒n ek y├╝k├╝ daha fazlad─▒r. ArrayLists bu ek y├╝k├╝ yok. Ancak, ArrayLists ger├žekte eklenmi┼č olup olmad─▒─č─▒na bak─▒lmaks─▒z─▒n, kapasiteye ayr─▒lan kadar bellek al─▒n.

Varsay─▒lan ba┼člang─▒├ž ÔÇőÔÇőkapasitesi ArrayList olduk├ža k├╝├ž├╝kt├╝r (10'dan Java 1.4 - 1.8'e kadar). Ancak, temel uygulama bir dizi oldu─čundan, ├žok say─▒da ├Â─če eklerseniz dizinin yeniden boyutland─▒r─▒lmas─▒ gerekir. ├çok say─▒da eleman ekleyece─činizi bildi─činiz zaman yeniden boyutland─▒rma maliyetinin y├╝ksek olmas─▒ndan ka├ž─▒nmak i├žin, ArrayList daha y├╝ksek bir ba┼člang─▒├ž ÔÇőÔÇőkapasitesi ile olu┼čturun.


3216







┼×imdiye kadar, hi├ž kimse bu listelerin her birinin haf─▒za ayak izini ele alm─▒yor gibi g├Âz├╝k├╝yor, genel fikir birli─činin yan─▒ s─▒ra, a'n─▒n LinkedList "├žok daha fazla" oldu─ču konusunda genel bir fikir birli─čine ArrayList vard─▒m.

Referanslar g├Âreceli sistemlerinde 32 veya 64 bit (bo┼č olsalar bile) oldu─čundan, 32 ve 64 bit i├žin 4 veri setini dahil ettim LinkedLists ve ArrayLists .

Not: ArrayList ├çizgiler i├žin g├Âsterilen boyutlar kesilmi┼č listeler i├žindir - Uygulamada, bir dizideki destek dizisinin kapasitesi ArrayList genel olarak ge├žerli ├Â─če say─▒s─▒ndan daha b├╝y├╝kt├╝r.

Not 2: (te┼čekk├╝rler BeeOnRope) CompressedOops ┼ču anda varsay─▒lan JDK6 ve ├╝st├╝ standartlarda oldu─ču i├žin, 64-bit makineler i├žin a┼ča─č─▒daki de─čerler, temelde ├Âzellikle kapatmad─▒─č─▒n─▒z s├╝rece, 32-bit emsalleriyle temelde e┼čle┼čecektir.



LinkedList ve ArrayList Grafi─či ├ľ─če Say─▒s─▒ x Bayt


Sonu├ž a├ž─▒k├ža , ├Âzellikle ├žok y├╝ksek bir element say─▒s─▒yla , bunun LinkedList bir hayli fazla oldu─čunu g├Âsteriyor ArrayList . Bellek bir fakt├Âr ise, uzak durun LinkedLists .

Kulland─▒─č─▒m form├╝ller takip ediyor, yanl─▒┼č bir ┼čey yapt─▒ysam haberim olsun, d├╝zeltece─čim. 'b', 32 veya 64 bit sistemler i├žin 4 veya 8'dir ve 'n', ├Â─čelerin say─▒s─▒d─▒r. Modlar─▒n nedeninin, java'daki t├╝m nesnelerin, kullan─▒lm─▒┼č olup olmamas─▒na bak─▒lmaks─▒z─▒n, 8 baytl─▒k bir kat─▒ alaca─č─▒ndan kaynakland─▒─č─▒na 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)


605







ArrayList ─░stedi─čin ┼čey bu. LinkedList Neredeyse her zaman (performans) bir hatad─▒r.

Neden LinkedList berbat:

  • ├çok say─▒da k├╝├ž├╝k bellek nesnesi kullan─▒r ve bu nedenle i┼člem boyunca performans─▒ etkiler.
  • ├çok say─▒da k├╝├ž├╝k nesne, ├Ânbellek yerelli─či i├žin k├Ât├╝d├╝r.
  • Herhangi bir endekslenmi┼č i┼člem, bir ge├ži┼č gerektirir, yani O (n) performans─▒na sahiptir. Bu, kaynak kodda a├ž─▒k de─čildir ve O (n) algoritmalar─▒n─▒n ArrayList kullan─▒ld─▒─č─▒ndan daha yava┼č olmas─▒na neden olur .
  • ─░yi performans almak zor.
  • B├╝y├╝k O performans─▒ ayn─▒ olsa bile ArrayList , muhtemelen yine de ├Ânemli ├Âl├ž├╝de yava┼člayacakt─▒r.
  • LinkedList Kaynakta g├Ârmek zordur, ├ž├╝nk├╝ muhtemelen yanl─▒┼č bir se├žimdir.

226







Operasyonel performans m├╝hendisli─či konusunda yakla┼č─▒k on y─▒ld─▒r ├žok b├╝y├╝k ├Âl├žekli SOA web hizmetleri yapan biri olarak, LinkedList'in ArrayList'e g├Âre davran─▒┼č─▒n─▒ tercih ederim. LinkedList'in kararl─▒ durum verimi daha k├Ât├╝ olsa da bu nedenle daha fazla donan─▒m sat─▒n almaya yol a├žabilir - ArrayList'in bask─▒ alt─▒ndaki davran─▒┼č─▒, k├╝melerdeki uygulamalar─▒n dizileri yak─▒n e┼čzamanl─▒l─▒kta ve b├╝y├╝k dizi boyutlar─▒ i├žin geni┼čletmesine neden olabilir uygulamada ve bir kesinti, bask─▒ alt─▒nda iken, bu felaket bir davran─▒┼č.

Benzer ┼čekilde, varsay─▒lan i┼č hacmine sahip ├ž├Âp toplay─▒c─▒s─▒ndan bir uygulamada daha iyi verim elde edebilirsiniz, ancak bir kez 10GB y─▒─č─▒nla java uygulamalar─▒ elde etti─činizde, SOA uygulamalar─▒nda zaman a┼č─▒m─▒na ve ar─▒zalara neden olan bir Tam GC s─▒ras─▒nda uygulamay─▒ 25 saniye boyunca kilitlemeye ba┼člayabilirsiniz ve SLA'lar─▒n─▒z─▒ ├žok s─▒k meydana gelirse patlat─▒r. CMS toplay─▒c─▒s─▒ daha fazla kaynak alsa ve ayn─▒ ham i┼č hacmine ula┼čmasa da, daha iyi bir se├žim ├ž├╝nk├╝ daha ├Âng├Âr├╝lebilir ve daha k├╝├ž├╝k gecikme s├╝resi var.

ArrayList, yaln─▒zca performansla kastetti─čin t├╝m verim ise ve gecikmeyi g├Ârmezden gelebilirsen performans i├žin daha iyi bir se├žimdir. ─░┼č yerimdeki tecr├╝beme g├Âre, en k├Ât├╝ gecikmeyi g├Âz ard─▒ edemem.


137







 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 Notasyonu

ArrayLists birkez okur-bir├žok yazar veya kullan─▒c─▒ i├žin iyidir ancak ├Ânden veya ortadan ekleme / ├ž─▒karma i┼člemlerinde k├Ât├╝d├╝r.


124







Evet, biliyorum, bu eski bir soru, ama iki sentimi de ataca─č─▒m:

LinkedList , performans a├ž─▒s─▒ndan neredeyse her zaman yanl─▒┼č se├žimdir. LinkedList'in ├ža─čr─▒ld─▒─č─▒ baz─▒ ├žok ├Âzel algoritmalar vard─▒r, ancak bunlar ├žok nadirdir ve algoritma genellikle LinkedList'in listenin ortas─▒ndaki ├Â─čeleri nispeten h─▒zl─▒ bir ┼čekilde yerle┼čtirdi─činiz ve sildi─činiz yetene─čine ba─čl─▒d─▒r. ListIterator ile.

LinkedList'in ArrayList'ten daha iyi bir performans g├Âsterdi─či yayg─▒n bir kullan─▒m durumu vard─▒r: bir s─▒ran─▒nki. Bununla birlikte, hedefiniz performanssa LinkedList yerine, bir ArrayBlockingQueue kullanmay─▒ da d├╝┼č├╝nmelisiniz (zaman─▒ndan ├Ânce kuyruk b├╝y├╝kl├╝─č├╝n├╝ze bir ├╝st s─▒n─▒r belirleyebilirseniz ve t├╝m bu bellekleri ├Ânceden tahsis edebiliyorsan─▒z) veya bu CircularArrayList uygulamas─▒n─▒ da . (Evet, 2001ÔÇÖden beri, bu nedenle onu yeniden tan─▒mlaman─▒z gerekecek, ancak daha yeni bir JVMÔÇÖdeki makalede al─▒nt─▒lananlarla kar┼č─▒la┼čt─▒r─▒labilir performans oranlar─▒ elde ettim)


103







Bu bir verimlilik sorusu. LinkedList ├Â─čeleri eklemek ve silmek i├žin h─▒zl─▒, ancak belirli bir ├Â─čeye eri┼čmek i├žin yava┼č. ArrayList belirli bir ├Â─čeye eri┼čmek i├žin h─▒zl─▒d─▒r, ancak her iki ucuna eklemek i├žin yava┼č olabilir ve ├Âzellikle ortada silmek i├žin yava┼č olabilir.

ArrayList vs ArrayList - LinkedList vs Vector , Ba─člant─▒l─▒ Liste gibi, daha derinlemesine gider .


61







Do─čru veya Yanl─▒┼č: L├╝tfen yerel olarak test yap─▒n ve kendiniz karar verin!

D├╝zenleme / Kald─▒r h─▒zl─▒ oldu─čundan LinkedList daha ArrayList .

ArrayList Taraf─▒ndan desteklenen Array , iki kat─▒ olmas─▒ gerekmektedir b├╝y├╝k hacimli bir uygulama k├Ât├╝ olan.

A┼ča─č─▒da her i┼člem i├žin birim test sonucu verilmi┼čtir. Zamanlama Nanosaniye cinsinden 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);
    }
}
 

53


2011-09-21





ArrayList asl─▒nda bir dizi. LinkedList ├žift ÔÇőÔÇőba─člant─▒l─▒ bir liste olarak uygulanmaktad─▒r.

get Olduk├ža a├ž─▒kt─▒r. O (1) ArrayList , ├ž├╝nk├╝ ArrayList indeks kullanarak rastgele eri┼čime izin verin. O (n) LinkedList ├ž├╝nk├╝ ilk ├Ânce endeksi bulmas─▒ gerekiyor. Not: add ve farkl─▒ s├╝r├╝mleri vard─▒r remove .

LinkedList ekleme ve ├ž─▒karma i┼člemlerinde daha h─▒zl─▒d─▒r, ancak alma i┼člemlerinde daha yava┼čt─▒r. K─▒sacas─▒, LinkedList e─čer tercih edilmelidir:

  1. Eleman─▒n ├žok say─▒da rasgele eri┼čimi yok
  2. ├çok say─▒da ekleme / ├ž─▒karma i┼člemi var

=== ArrayList ===

  • ekle (E e)
    • ArrayList'in sonuna ekle
    • bellek boyutland─▒rma maliyeti gerektirir.
    • O (n) en k├Ât├╝, O (1) itfa edilmi┼č
  • ekle (int dizini, E ├Â─česi)
    • belirli bir indeks pozisyonuna ekle
    • kayd─▒rma ve olas─▒ bellek boyutland─▒rma maliyeti gerektirir
    • O (n)
  • kald─▒r (int index)
    • belirtilen ├Â─čeyi kald─▒r
    • kayd─▒rma ve olas─▒ bellek boyutland─▒rma maliyeti gerektirir
    • O (n)
  • Kald─▒r (Object o)
    • belirtilen ├Â─čenin ilk olu┼čumunu bu listeden kald─▒r
    • ├Ânce ├Â─čeyi araman─▒z, sonra da kayd─▒rma ve olas─▒ bellek boyutland─▒rma maliyetini
    • O (n)

=== LinkedList ===

  • ekle (E e)

    • listenin sonuna ekle
    • O (1)
  • ekle (int dizini, E ├Â─česi)

    • belirtilen pozisyonda yerle┼čtirin
    • ├Ânce pozisyonu bulmam─▒z gerek
    • O (n)
  • Kald─▒r()
    • listenin ilk ├Â─česini kald─▒r
    • O (1)
  • kald─▒r (int index)
    • belirtilen dizini i├žeren ├Â─čeyi kald─▒r
    • ├Ânce ├Â─čeyi bulman─▒z gerek
    • O (n)
  • Kald─▒r (Object o)
    • belirtilen ├Â─čenin ilk olu┼čumunu kald─▒r
    • ├Ânce ├Â─čeyi bulman─▒z gerek
    • O (n)

─░┼čte programcreek.com adresinden bir rakam ( add ve remove ilk t├╝r, yani listenin sonuna bir ├Â─če ekleyin ve ├Â─čeyi listede belirtilen konumda kald─▒r─▒n.):


g├Âr├╝nt├╝ tan─▒m─▒n─▒ buraya girin


48


2013-04-21





LinkedList'in yazar─▒ Joshua Bloch:

LinkedList'i ger├žekten kullanan var m─▒? Yazd─▒m ve asla kullanmam.

Ba─člant─▒: https://twitter.com/joshbloch/status/583813919019573248

Di─čer cevaplar kadar bilgilendirici olmad─▒─č─▒m i├žin cevap i├žin ├Âz├╝r dilerim, ancak bunun en ilgin├ž ve a├ž─▒klay─▒c─▒ olaca─č─▒n─▒ d├╝┼č├╝nd├╝m.


38







ArrayList rastgele eri┼čilebilir, LinkedList ├Â─čeleri geni┼čletmek ve kald─▒rmak ger├žekten ucuz olsa da. ├ço─ču durumda, ArrayList iyidir.

B├╝y├╝k listeler olu┼čturup bir t─▒kan─▒kl─▒k ├Âl├žmediyseniz, muhtemelen hi├žbir zaman endi┼če duyman─▒za gerek kalmayacak.


33







Kodunuzda add(0) ve varsa remove(0) , a LinkedList ve daha g├╝zel addFirst() ve removeFirst() y├Ântemleri kullan─▒n. Aksi takdirde, kullan─▒n ArrayList .

Ve tabii ki, Guava 'in ImmutableList en iyi arkada┼č─▒n─▒zd─▒r.


23







Bunun eski bir yaz─▒ oldu─čunu biliyorum, ama d├╝r├╝st├že, bunun LinkedList uygulayan kimseden bahsetmedi─čine inanam─▒yorum Deque . Sadece Deque (ve Queue ) ' deki metodlara bak─▒n ; E─čer adil bir kar┼č─▒la┼čt─▒rma yapmak istiyorsan─▒z, LinkedList kar┼č─▒ koymay─▒ deneyin ArrayDeque ve ├Âzellik i├žin bir kar┼č─▒la┼čt─▒rma yap─▒n.


21


2013-04-19





TL; DR , modern bilgisayar mimarisine ba─čl─▒ olarak, ArrayList neredeyse t├╝m olas─▒ kullan─▒m durumlar─▒ i├žin ├Ânemli ├Âl├ž├╝de daha verimli olacakt─▒r - ve bu nedenle LinkedList , baz─▒ benzersiz ve a┼č─▒r─▒ durumlar d─▒┼č─▒nda sak─▒n─▒lmal─▒d─▒r.


Teorik olarak LinkedListÔÇÖin bir O (1) add(E element)

Ayr─▒ca listenin ortas─▒na bir eleman eklemek ├žok verimli olmal─▒.

LinkedList bir Cache Hostile Data yap─▒s─▒ oldu─ču i├žin uygulama ├žok farkl─▒ . Performans POV'sundan - ├Ânbellek dostu LinkedList performanstan daha iyi performans g├Âsterebilecek ├žok az durum vard─▒r . ArrayList

─░┼čte rasgele konumlara eleman ekleyen bir k─▒yaslama testinin sonu├žlar─▒. G├Ârd├╝─č├╝n├╝z gibi - ├žok daha verimli ise dizi listesi, teoride listenin ortas─▒ndaki her bir ek , dizinin sonraki n ├Â─čelerini "ta┼č─▒mak" gerektirecektir (d├╝┼č├╝k de─čerler daha iyidir):


g├Âr├╝nt├╝ tan─▒m─▒n─▒ buraya girin

Daha sonraki nesil bir donan─▒m ├╝zerinde ├žal─▒┼čmak (daha b├╝y├╝k, daha verimli ├Ânbellek) - sonu├žlar daha da kesin:


g├Âr├╝nt├╝ tan─▒m─▒n─▒ buraya girin

LinkedList ayn─▒ i┼či ba┼čarmak i├žin ├žok daha fazla zaman al─▒r. kaynak Kaynak Kodu

Bunun iki ana nedeni var:

  1. Temelde - d├╝─č├╝mleri LinkedList rasgele rastgele da─č─▒lm─▒┼č durumda. RAM ("Random Access Memory") ger├žekten rastgele de─čildir ve ├Ânbellek i├žin haf─▒za bloklar─▒n─▒n al─▒nmas─▒ gerekir. Bu i┼člem zaman al─▒r ve bu t├╝r al─▒mlar s─▒k ÔÇőÔÇős─▒k ger├žekle┼čti─činde - ├Ânbellekteki bellek sayfalar─▒n─▒n her zaman de─či┼čtirilmesi gerekir -> ├ľnbellek ├Âzl├╝yor -> ├ľnbellek etkin de─čildir. ArrayList elemanlar s├╝rekli bellekte saklan─▒r - bu da tam olarak modern CPU mimarisinin en iyi duruma getirdi─či ┼čeydir.

  2. ─░kincil LinkedList i┼čaret├žileri geri / ileri tutmak i├žin gereklidir, bu de─čer, kaydedilen de─čer ba┼č─▒na kaydedilen de─čerin 3 kat─▒ anlam─▒na gelir ArrayList .

DynamicIntArray , btw, Object'leri Int de─čil (ilkel t├╝r) tutan ├Âzel bir ArrayList uygulamas─▒d─▒r - bu nedenle t├╝m veriler ger├žekten biti┼čik olarak depolan─▒r - dolay─▒s─▒yla daha da verimlidir.

Hat─▒rlanmas─▒ gereken en ├Ânemli unsurlardan biri, haf─▒za blo─čunu alma maliyetinin, tek bir haf─▒za h├╝cresine eri┼čim maliyetinden daha ├Ânemli olmas─▒d─▒r. Bu nedenle, 1 MB s─▒ral─▒ bellek okuyucusunun, farkl─▒ bellek bloklar─▒ndaki bu veri miktar─▒n─▒ okumaktan x400 kat daha h─▒zl─▒ olmas─▒:

 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 Numaralar─▒

Sadece noktay─▒ daha da netle┼čtirmek i├žin, l├╝tfen listenin ba┼č─▒na ├Â─če ekleme kriterini kontrol edin. Bu, teoride, LinkedList ger├žekten parlamas─▒ ArrayList gereken ve k├Ât├╝ veya daha k├Ât├╝ durum sonu├žlar─▒ sunan bir kullan─▒m durumudur:


g├Âr├╝nt├╝ tan─▒m─▒n─▒ buraya girin

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┼čtirir ve asl─▒nda tekrar ArrayList / Vector ├žok daha verimli hale getirir


Kredi: Burada yay─▒nlanan t├╝m kriterler Kjell Hedstr├Âm taraf─▒ndan olu┼čturulmu┼čtur . Daha da veri bulunabilir blogunda


20







─░┼čte hem Big-O g├Âsterimi olan ArrayList ve LinkedList ayr─▒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. :)


18







LinkedList ve ArrayList wrt parametrelerini a┼ča─č─▒da kar┼č─▒la┼čt─▒ral─▒m:

1. Uygulama

ArrayList , liste aray├╝z├╝n├╝n yeniden boyutland─▒r─▒labilir dizi uygulamas─▒d─▒r.

LinkedList , liste arabiriminin Doubly-ba─člant─▒l─▒ liste uygulamas─▒d─▒r.


2. Performans

  • get (int index) veya arama i┼člemi

    ArrayList get (int index) i┼člemi sabit zamanda ├žal─▒┼č─▒r, yani O (1)

    LinkedList get (int index) i┼čleminin ├žal─▒┼čma s├╝resi O (n) 'dir.

    ArrayList'in LinkedList'ten daha h─▒zl─▒ olmas─▒n─▒n sebebi , ArrayList'in dahili olarak bir dizi veri yap─▒s─▒n─▒ kulland─▒─č─▒ i├žin ├Â─čeleri i├žin dizin tabanl─▒ bir sistem kullanmas─▒d─▒r.

    LinkedList , ├Â─čelerini belirtilen ├Â─če dizinindeki d├╝─č├╝m├╝ almak i├žin ba┼čtan veya sondan tekrarlanan (hangisi daha yak─▒nsa) yinelendi─či i├žin, ├Â─čelerine dizin tabanl─▒ eri┼čim sa─člamaz.

  • insert () veya add (Object) i┼člemi

    ─░├žinde Eklemeler LinkedList genellikle h─▒zl─▒ ┼čekilde ArrayList kar┼č─▒la┼čt─▒rmak edilir. LinkedList'te ekleme veya ekleme O (1) i┼člemidir.

    ─░ken ArrayList dizi tam yani k├Ât├╝ durum ise, diziyi yeniden boyutland─▒rma ve ArrayList O (n) 'de ekleme i┼člemi ├žal─▒┼čma zaman─▒n─▒ yapan yeni dizi i├žin elemanlar─▒n─▒ kopyalama ekstra ├╝cret yoktur aksi takdirde (1) O .

  • (int) i┼člemini kald─▒r

    LinkedList'teki i┼člemi kald─▒r, genellikle ArrayList ile ayn─▒d─▒r, yani O (n).

    In LinkedList , iki A┼č─▒r─▒ y├╝kl├╝ kald─▒r y├Ântemi vard─▒r. bunlardan biri listenin ba┼č─▒n─▒ kald─▒ran ve O (1) sabit s├╝relerinde ├žal─▒┼čan herhangi bir parametre olmadan remove () i┼člevidir. LinkedList'teki di─čer a┼č─▒r─▒ y├╝klenmi┼č kald─▒rma y├Ântemi, Object'i veya parametre olarak ge├žirilen int'yi kald─▒ran remove (int) veya remove (Object) 'dir. Bu y├Ântem, Object'i bulana ve orijinal listeden ba─člant─▒s─▒n─▒ kald─▒rana kadar LinkedList'i ge├žirir. Dolay─▒s─▒yla 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 () komutunu kullanarak ters y├Ânde yinelenebilir.

ArrayList'te bir descendingIterator () yoktur , bu nedenle ArrayList ├╝zerinde ters y├Ânde yineleme yapmak i├žin kendi kodumuzu yazmam─▒z gerekir.


4. ─░lk Kapasite

Yap─▒c─▒ a┼č─▒r─▒ y├╝klenmediyse, ArrayList , ba┼člang─▒├ž ÔÇőÔÇőkapasitesi 10 olan bo┼č bir liste olu┼čturur.

LinkedList , bo┼č listeyi yaln─▒zca ba┼člang─▒├ž ÔÇőÔÇőkapasitesi olmadan olu┼čturur.


5. Haf─▒za Y├╝k├╝

LinkedList'teki bellek ek y├╝k├╝ , bir sonraki ve ├Ânceki d├╝─č├╝m├╝n adreslerini korumak i├žin LinkedList'teki bir d├╝─č├╝m gibi ArrayList ile kar┼č─▒la┼čt─▒r─▒ld─▒─č─▒nda daha fazlad─▒r. S├╝re

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


Kaynak


16







Yukar─▒daki di─čer iyi arg├╝manlara ek olarak, ArrayList uygulama RandomAccess aray├╝z├╝n├╝ kullan─▒rken LinkedList uygulama aray├╝z├╝n├╝ fark etmelisiniz Queue .

Bu nedenle, bir ┼čekilde verimlilik ve davran─▒┼č farkl─▒l─▒klar─▒yla biraz farkl─▒ problemleri ele al─▒yorlar (y├Ântem listesine bak─▒n─▒z).


14







Genellikle belirli bir Listede ger├žekle┼čtirdi─čim i┼člemlerin zaman karma┼č─▒kl─▒─č─▒na ba─čl─▒ olarak bir ba┼čkas─▒n─▒ kullan─▒r─▒m.

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

13











Bu, Listede hangi i┼člemleri daha ├žok yapaca─č─▒n─▒za ba─čl─▒d─▒r.

ArrayList Dizine al─▒nm─▒┼č bir de─čere eri┼čmek i├žin daha h─▒zl─▒d─▒r. Nesne eklerken veya silerken ├žok daha k├Ât├╝.

Daha fazla bilgi edinmek i├žin, diziler ve ba─člant─▒l─▒ listeler aras─▒ndaki farktan bahseden t├╝m makaleleri okuyun.


9







Bir dizi listesi, temel olarak ├Â─čeler vb. Ekleme y├Ântemleri i├žeren bir dizidir (bunun yerine genel bir liste kullanmal─▒s─▒n─▒z). Dizin olu┼čturucudan eri┼čilebilen bir ├Â─če koleksiyonudur (├Ârne─čin [0]). Bir ├Â─čeden di─čerine ilerleme anlam─▒na gelir.

Ba─člant─▒l─▒ bir liste, bir maddeden di─čerine bir ilerleme belirtir (Madde a -> madde b). Bir dizi listesiyle ayn─▒ etkiyi elde edebilirsiniz, ancak ba─člant─▒l─▒ bir liste kesinlikle hangi ├Â─čenin ├Ânceki ├Â─čeyi izlemesi gerekti─čini s├Âyl├╝yor.


8







Ba─člant─▒l─▒ bir listenin (ba┼čka bir cevab─▒nda okumad─▒─č─▒m) ├Ânemli bir ├Âzelli─či iki listenin birle┼čtirilmesidir. Bir diziyle bu, O (n) 'dir (+ baz─▒ yeniden tahsislerin ek y├╝k├╝) ba─člant─▒l─▒ bir listeyle bu sadece O (1) veya O (2) ;-)

├ľnemli : Java i├žin LinkedList bu do─čru de─čil! Bkz Java ba─člant─▒l─▒ liste i├žin h─▒zl─▒ bir concat y├Ântem var m─▒?


7







Yan─▒tlar─▒ okudum, ancak ArrayList ├╝zerinde her zaman LinkedList'i kullanarak fikir duymak i├žin payla┼čmak istedi─čim bir senaryo var:

Her zaman bir DB'den elde edilen verilerin listesini d├Ând├╝ren bir y├Ântemim olsayd─▒, her zaman LinkedList kullan─▒r─▒m.

Benim mant─▒─č─▒m ┼čuydu: Ka├ž tane sonu├ž ald─▒─č─▒m─▒ tam olarak bilmek imkans─▒z oldu─ču i├žin, haf─▒zan─▒n bo┼ča harcanmayaca─č─▒na (kapasite ve ger├žek ├Â─če say─▒s─▒ aras─▒ndaki ArrayList'teki gibi) ve ├žal─▒┼čmaya ├žal─▒┼č─▒rken bo┼ča zaman harcanmayaca─č─▒na karar verildi. kapasiteyi ├žo─čalt.

Bir ArrayList'e kadar, dizilerin ├žo─čalt─▒lmas─▒n─▒ m├╝mk├╝n oldu─ču kadar en aza indirgemek i├žin en az─▒ndan her zaman ilk kapasiteyle yap─▒c─▒y─▒ kullanman─▒z gerekti─čine kat─▒l─▒yorum.


6







ArrayList ve LinkedListÔÇÖin kendi art─▒lar─▒ ve eksileri var.

ArrayList, bir sonraki d├╝─č├╝me do─čru i┼čaret├žiler kullanan LinkedList ile kar┼č─▒la┼čt─▒r─▒ld─▒─č─▒nda biti┼čik bellek adresini kullan─▒r. Bu nedenle, bir ArrayList'teki bir ├Â─čeyi aramak istedi─činizde LinkedList ile yineleme yapmaktan daha h─▒zl─▒d─▒r.

├ľte yandan, LinkedList'e ekleme ve silme i┼člemi ├žok daha kolayd─▒r, ├ž├╝nk├╝ sadece i┼čaret├žileri de─či┼čtirmeniz gerekir, oysa ArrayList herhangi bir ekleme veya silme i├žin vardiya i┼člemi kullan─▒m─▒ anlam─▒na gelir.

Uygulaman─▒zda s─▒k s─▒k al─▒m i┼člemleriniz varsa, bir ArrayList kullan─▒n. S─▒k s─▒k ekleme ve silme i┼člemine sahipseniz LinkedList kullan─▒n.


6







ArrayList ve LinkedList hem uygular List interface hem de metotlar─▒ ve sonu├žlar─▒ neredeyse ayn─▒d─▒r. Ancak, gereksinime ba─čl─▒ olarak birbirini daha iyi yapan aralar─▒nda ├žok az fark vard─▒r.

Dizi Listesi Vs LinkedList

1) Search: ArrayList arama i┼člemi arama i┼člemi ile kar┼č─▒la┼čt─▒r─▒ld─▒─č─▒nda olduk├ža h─▒zl─▒ LinkedList . get(int index) i├žinde ArrayList performans─▒n─▒ verir O(1) iken LinkedList performanst─▒r O(n) .

Reason: ArrayList Dizin tabanl─▒ bir sistemi, dizi veri yap─▒s─▒n─▒ dolayl─▒ olarak kulland─▒─č─▒ i├žin, listedeki bir ├Â─čeyi aramay─▒ h─▒zland─▒r─▒r. Di─čer tarafta LinkedList , bir eleman aramak i├žin t├╝m elemanlar aras─▒nda ge├ži┼či gerektiren iki kat ba─člant─▒l─▒ bir liste uygular.

2) Deletion: LinkedList ├ž─▒karma i┼člemi de─či┼čken O(1) performans sa─člarken performans ArrayList verir: O(n) en k├Ât├╝ durumda (ilk eleman─▒ ├ž─▒kar─▒rken) ve O(1) en iyi durumda (Son eleman─▒ ├ž─▒kar─▒rken).

Sonu├ž: LinkedList elemanlar─▒n─▒n silinmesi, ArrayList ile kar┼č─▒la┼čt─▒r─▒ld─▒─č─▒nda daha h─▒zl─▒d─▒r.

Sebep: LinkedList'in her ├Â─česi, listedeki her iki kom┼ču ├Â─čeye de i┼čaret eden iki i┼čaret├ži (adres) tutar. Bu nedenle kald─▒r─▒lmas─▒, yaln─▒zca kald─▒r─▒lacak olan d├╝─č├╝m├╝n iki kom┼ču d├╝─č├╝m├╝ndeki (eleman) i┼čaret├ži konumunda de─či┼čiklik gerektirir. ArrayList'te, kald─▒r─▒lan eleman─▒n yaratt─▒─č─▒ bo┼člu─ču doldurmak i├žin t├╝m elemanlar─▒n kayd─▒r─▒lmas─▒ gerekir.

3) Inserts Performance: LinkedList ekleme y├Ântemi en k├Ât├╝ durumda O(1) verirken performans ArrayList verir O(n) . Sebep, kald─▒r─▒lmas─▒ i├žin a├ž─▒klanan ayn─▒d─▒r.

4) Memory Overhead: ArrayList indeksleri ve element verilerini korurken LinkedList , element verilerini ve kom┼ču d├╝─č├╝mler i├žin iki i┼čaret├ži tutar.

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 uygulamas─▒d─▒r.
  • Her ikisi de eleman ekleme s─▒ras─▒n─▒ korur, bu ArrayList ve LinkedList ├Â─čelerini g├Âr├╝nt├╝lerken sonu├ž k├╝mesinin, ├Â─čelerin Listeye eklendi─či s─▒raya sahip olaca─č─▒ anlam─▒na gelir.
  • Her iki s─▒n─▒f da senkronize de─čildir ve Collections.synchronizedList y├Ântemi kullan─▒larak a├ž─▒k├ža senkronize edilebilir.
  • iterator Ve listIterator bu 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ÔÇÖs kendi kald─▒r veya ekleme y├Ântemleri, yineleyici olacak throw bir ConcurrentModificationException ).

LinkedList ne zaman ve ArrayList ne zaman kullan─▒l─▒r?

  • Yukar─▒da a├ž─▒kland─▒─č─▒ gibi, ekleme ve ├ž─▒karma i┼člemleri (O(1)) ile LinkedList kar┼č─▒la┼čt─▒r─▒ld─▒─č─▒nda iyi performans verir ArrayList(O(n)) .

    Dolay─▒s─▒yla, 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 i├žeride de─čil LinkedList (O(n))

    Bu nedenle, daha az ekleme ve ├ž─▒karma i┼člemi ve daha fazla arama i┼člemi gereksinimi varsa, ArrayList en iyi bahistir.


5







ArrayList'teki i┼člem (i), LinkedList'ten daha h─▒zl─▒d─▒r, ├ž├╝nk├╝:
ArrayList: Liste arabiriminin yeniden boyutland─▒r─▒labilir dizisi uygulamas─▒
LinkedList: Liste ve Deque arabirimlerinin ├žift ba─člant─▒l─▒ listesi uygulamas─▒

Listeye endeksleyen i┼člemler, belirtilen endekse hangisi daha yak─▒nsa listeyi en ba┼čtan veya en sondan ba┼člatacak.


5







1) Temel Veri Yap─▒s─▒

ArrayList ve LinkedList aras─▒ndaki ilk fark, LinkedList LinkedList taraf─▒ndan desteklenirken ArrayList'in Array taraf─▒ndan desteklenmesiyle gelir. Bu, performansta daha fazla farkl─▒l─▒klara yol a├žacakt─▒r.

2) LinkedList, Deque uygular

ArrayList ve LinkedList aras─▒ndaki di─čer bir fark, List arabiriminin yan─▒ s─▒ra, LinkedList'in ayr─▒ca add () ve poll () ve di─čer bir├žok Deque i┼člevi i├žin ilk giren ilk i┼člemleri sa─člayan Deque arabirimini uygulamas─▒d─▒r. 3) ArrayList ├Â─čelerinde ├Â─če ekleme ArrayList ├Â─česinde ├Â─če ekleme, Array ├Â─česinin yeniden boyutland─▒r─▒lmas─▒n─▒ tetiklemezse O (1) i┼člemidir, bu durumda O (log (n)) olur, di─čer taraftan, LinkedList, herhangi bir navigasyon gerektirmedi─činden O (1) i┼člemidir.

4) Bir eleman─▒ pozisyondan ├ž─▒karma

Bir eleman─▒ belirli bir dizinden kald─▒rmak i├žin, ├Ârne─čin remove (index) ├Â─česini ├ža─č─▒rmak suretiyle, ArrayList, O (n) 'ye yak─▒n yapan bir kopya i┼člemi ger├žekle┼čtirirken LinkedList'in de O (n / 2) yapan noktay─▒ ge├žmesi gerekir. , yak─▒nl─▒─ča ba─čl─▒ olarak her iki y├Ânden de ge├žebilece─či i├žin.

5) ArrayList veya LinkedList ├╝zerinde yineleme

Yineleme hem LinkedList hem de ArrayList i├žin O (n) i┼člemidir, burada n bir elemand─▒r.

6) Bir pozisyondan eleman alma

Get (index) i┼člemi ArrayList'te O (1) olurken, LinkedList'te O (n / 2) girilir. Yine de, B├╝y├╝k O'da notasyon O (n / 2) sadece O (n) 'dir ├ž├╝nk├╝ oradaki sabitleri g├Ârmezden geliyoruz.

7) Haf─▒za

LinkedList, ArrayList yaln─▒zca Array'de veri depolarken, verileri saklamak i├žin statik bir yuvalanm─▒┼č s─▒n─▒f olan ve sonraki ve ├Ânceki iki d├╝─č├╝m├╝ i├žeren bir sarmalay─▒c─▒ nesnesini kullan─▒r.

Bu nedenle, ArrayList durumunda, i├žeri─či Array'den di─čerine kopyalad─▒─č─▒nda, Array'in yeniden boyutland─▒rma i┼člemini ger├žekle┼čtirdi─či durumlar d─▒┼č─▒nda, bellek gereksinimi daha az g├Âr├╝n├╝r.

Dizi yeterince b├╝y├╝kse, bu noktada ├žok fazla bellek alabilir ve yan─▒t s├╝resini yava┼člatabilecek ├ç├Âp toplamas─▒n─▒ tetikleyebilir.

ArrayList ile LinkedList aras─▒ndaki t├╝m yukar─▒daki farkl─▒l─▒klardan, ArrayList, remove () veya get () i┼člevinden daha s─▒k bir add () i┼člemi yapt─▒─č─▒n─▒z durumlar d─▒┼č─▒nda, hemen hemen her durumda, ArrayList LinkedList'ten daha iyi bir se├žimdir.

Ba─člant─▒l─▒ bir listeyi de─či┼čtirmek ArrayList'ten daha kolayd─▒r, ├Âzellikle de ba┼čtan veya sondan eleman ekler veya ├ž─▒kar─▒rsan─▒z, ba─člant─▒l─▒ liste dahili olarak bu konumlar─▒n referanslar─▒n─▒ tutar ve O (1) zaman─▒nda eri┼čilebilir durumda olurlar.

Ba┼čka bir deyi┼čle, eleman eklemek istedi─činiz pozisyona ula┼čmak i├žin ba─člant─▒l─▒ listede dola┼čman─▒z gerekmez, bu durumda toplama O (n) i┼člemi olur. ├ľrne─čin, ba─člant─▒l─▒ bir listenin ortas─▒na bir ├Â─če eklemek veya silmek.

Bence, Java'daki pratik ama├žlar─▒n ├žo─ču i├žin ArrayList'i LinkedList ├╝zerinden kullan─▒n.


5







Remove () ve insert () hem ArrayLists hem de LinkedLists i├žin ├žal─▒┼čma zaman─▒ verimlili─čine sahiptir (n). Bununla birlikte, lineer i┼člem s├╝resinin ard─▒ndaki sebep ├žok farkl─▒ iki nedenden kaynaklanmaktad─▒r:

Bir ArrayList'te O (1) ├Â─česindeki ├Â─čeye ula┼č─▒rs─▒n─▒z, ancak asl─▒nda bir ┼čeyi ├ž─▒karmak veya eklemek, O (n) 'yi yapar, ├ž├╝nk├╝ a┼ča─č─▒daki t├╝m ├Â─čelerin de─či┼čtirilmesi gerekir.

LinkedList'te asl─▒nda istenen ├Â─čeye ula┼čmak i├žin O (n) gerekir, ├ž├╝nk├╝ istenen dizine ula┼čana kadar en ba┼čtan ba┼člamak zorunday─▒z. Asl─▒nda kald─▒rma veya ekleme sabittir, ├ž├╝nk├╝ biz remove () i├žin yaln─▒zca 1 referans─▒ ve insert () i├žin 2 referans─▒ de─či┼čtirmemiz gerekir.

─░kisinden hangisinin tak─▒lmas─▒ ve ├ž─▒kar─▒lmas─▒ i├žin daha h─▒zl─▒ oldu─ču, nerede oldu─čuna ba─čl─▒d─▒r. E─čer ba┼člang─▒c─▒m─▒za daha yak─▒n olursak LinkedList daha h─▒zl─▒ olacakt─▒r ├ž├╝nk├╝ nispeten az say─▒da elementten ge├žmek zorunday─▒z. Sona yakla┼č─▒rsak, bir ArrayList daha h─▒zl─▒ olacakt─▒r, ├ž├╝nk├╝ oraya sabit zamanda varaca─č─▒z ve onu takip eden sadece birka├ž kalan ├Â─čeyi de─či┼čtirmek zorunda kalaca─č─▒z. Kesin olarak ortada yap─▒ld─▒─č─▒nda LinkedList daha h─▒zl─▒ olacakt─▒r ├ž├╝nk├╝ n elemanlar─▒ndan ge├žmek hareketli n de─čerlerinden daha h─▒zl─▒d─▒r.

Bonus: Bu iki y├Ântemi bir ArrayList i├žin O (1) yapman─▒n bir yolu olmamas─▒na ra─čmen, asl─▒nda LinkedLists'ta bunu yapman─▒n bir yolu yoktur. Diyelim ki t├╝m Listeyi yolumuza ekleyip ├Â─čeleri ekleyerek ge├žmek istiyoruz. Genellikle LinkedList'i kullanarak her bir eleman i├žin en ba┼čtan ba┼člars─▒n─▒z, ├╝zerinde ├žal─▒┼čt─▒─č─▒m─▒z mevcut ├Â─čeyi bir Yineleyici ile ÔÇťkaydedebilirizÔÇŁ. Yineleyici yard─▒m─▒yla, LinkedList'te ├žal─▒┼č─▒rken remove () ve insert () i├žin O (1) verimlilik elde ediyoruz. Bunu tek performans avantaj─▒ yaparak LinkedList'in her zaman bir ArrayList'ten daha iyi oldu─čunun fark─▒nday─▒m.


2







Burada g├Ârd├╝─č├╝m testlerden biri testi sadece bir kez ger├žekle┼čtiriyor. Ama farkettim ki, bu testleri bir ├žok kez denemeniz gerekiyor ve sonunda onlar─▒n zamanlar─▒ birle┼čiyor. Temel olarak JVM'nin ─▒s─▒nmas─▒ gerekiyor. ├ľzel kullan─▒m durumum i├žin, yakla┼č─▒k 500 ├Â─čeye ula┼čan bir son ├╝r├╝ne ekleme / ├ž─▒karma yapmam gerekiyordu. Testlerime g├Âre LinkedList daha h─▒zl─▒ ├ž─▒kt─▒, ba─člant─▒l─▒ LinkedList olarak yakla┼č─▒k 50.000 NS ArrayList geliyor 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;
}
 

2







ArrayList, AbstractList'i geni┼čletir ve Liste Aray├╝z├╝n├╝ uygular. ArrayList, dinamik bir dizidir.
Dizilerin dezavantajlar─▒n─▒n ├╝stesinden gelmek i├žin temelde yarat─▒ld─▒─č─▒ s├Âylenebilir

. LinkedList s─▒n─▒f─▒, AbstractSequentialList'i geni┼čletir ve List, Deque ve Queue aray├╝z├╝n├╝ 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)


1



─░lgili yay─▒nlar


CSS'de marj vs padding kullan─▒ld─▒─č─▒nda [kapal─▒]

Bu ne zaman kendini kendine kullanmal─▒?

CouchDB, MongoDBÔÇÖde ne zaman kullan─▒l─▒r?

SetAttribute vs .attribute = JavaScript'te ne zaman kullan─▒l─▒r?

Linq'te Cast () ve Oftype () ne zaman kullan─▒l─▒r?

Gelen bir sunucu uygulamas─▒ iste─či URL'sini de─či┼čtirmek i├žin Java'da sunucu uygulamas─▒ filtresi nas─▒l kullan─▒l─▒r?

TypeScript / Angular2'de Aray├╝z ve Model ne zaman kullan─▒l─▒r

IllegalMonitorStateException olmadan beklemek ve Java'da bildirmek nas─▒l kullan─▒l─▒r?

Ger├žek hayattan ├Ârnek, OUTER / CROSS APPLY'nin SQL'de ne zaman kullan─▒laca─č─▒

RDL raporlar─▒nda RDLC ne zaman kullan─▒l─▒r?

Etiketle ilgili di─čer sorular [java]


JQuery'deki bir SELECT ├Â─česinde belirli bir se├žene─či nas─▒l se├žersiniz?

JavaScript de─čerlendirme i┼člevini kullanmak neden k├Ât├╝ bir fikir?

Bash'te karma tablolar nas─▒l tan─▒mlan─▒r?

Bir dizgiyi bir karakter dizisine nas─▒l b├Âlerim?

JQuery CSS ├Âzelli─čini kullanarak arka plan resmini ayarlama

@Resource vs @Autowired

JavaÔÇÖda son anahtar kelimenin kullan─▒lmas─▒ performans─▒ art─▒r─▒r m─▒?

Java 8'de lambda'y─▒ parametre olarak alan bir y├Ântemi nas─▒l tan─▒mlar─▒m?

C++ 'daki dot (.) Operat├Âr├╝ ve -> aras─▒ndaki fark nedir? [├žift]

S─▒n─▒rlay─▒c─▒lar─▒ hari├ž tutarken iki karakter aras─▒nda bulunan bir dize bulmak i├žin Normal ─░fade