когда использовать linkedlist не более класса arraylist в java?

я всегда был один, чтобы просто использовать:

list<string> names = new arraylist<>();

portability

я использую интерфейс как имя типа , так что когда я задаю такие вопросы, я могу переработать свой код.

linkedlistarraylist

когда следует применять и наоборот?

Ответ 1

summaryarraylistarraydequemanylinkedlistarraylist

с предпочтительнее, чем больше дел, чем . если вы не уверены — просто начать .

linkedlistarraylistlinkedlistarraylist

и две различные реализации интерфейса list. реализует его с двусвязный список. реализует его динамическое изменение размера массива.

как со стандартной связанного списка и операций с массивами, различными методами будет иметь различные алгоритмические выполнения.

linkedlist<e>

для

get(int index) is o(n) (with n/4 steps on average)

add(e element) is o(1)

add(int index, e element) is o(n) (with n/4 steps on average), but o(1) when index = 0 <--- main benefit of linkedlist<e>

remove(int index) is o(n) (with n/4 steps on average)

iterator.remove() is o(1). <--- main benefit of linkedlist<e>

listiterator.add(e element) is o(1) this is one of the main benefits of linkedlist<e>

^{note: many of the operations need n/4 steps on average, constant number of steps in the best case (e.g. index = 0), and n/2 steps in worst case (middle of list)}arraylist<e>

для

get(int index) is o(1) <--- main benefit of arraylist<e>

add(e element) is o(1) amortized, but o(n) worst-case since the array must be resized and copied

add(int index, e element) is o(n) (with n/2 steps on average)

remove(int index) is o(n) (with n/2 steps on average)

iterator.remove() is o(n) (with n/2 steps on average)

listiterator.add(e element) is o(n) (with n/2 steps on average)

^{note: many of the operations need n/2 steps on average, constant number of steps in the best case (end of list), n steps in the worst case (start of list)}linkedlist<e>using iterators"operations that index into the list will traverse the list from the beginning or the end, whichever is closer"o(n)n/4o(1)index = 0

обеспечивает постоянное время вставки и удаления , но только последовательный доступ к элементам. другими словами, вы можете пройтись по списку вперед или назад, но найти позицию в списке занимает время, пропорциональное размеру списка. у javadoc говорит , поэтому эти методы ( действия) в среднем, хотя для .

arraylist<e>arraylisto(n)

с другой стороны, позволит быстрый произвольный доступ на чтение, так что вы можете захватить любой элемент в постоянное время. а добавив или удалив из любой точки мира, но конец требует переложив все последние элементы, либо сделать проем или заполнить пробел. также, если вы добавить больше элементов, чем емкость основной массив, новый массив (в 1.5 раза), и старого массива копируются в новый, чтобы добавить к это, в худшем случае, но постоянный в среднем.

arraylist

поэтому в зависимости от операций, которые вы собираетесь делать, вы должны выбрать соответственно реализации. перебора либо вид списка практически одинаково дешево. (повторяя за технически быстрее, но если вы делаете что-то очень чувствительные к производительности, вы не должны беспокоиться об этом-они обе константы.)

linkedlisto(1)movedlinkedlisto(n)n/2arraylisto(1)

основные преимущества использования возникают, когда вы повторно использовать существующие итераторы вставки и удаления элементов. эти операции могут быть выполнены в результате изменения списка только локально. в список массива, в оставшейся части массива, который должен быть (т. е. копируются). с другой стороны, ищет в средства по ссылкам в ( шагов) в худшем случае, а в нужном положении может быть математически рассчитаны и доступны в .

linkedlisto(1)o(n)arraylistarraydequelinkedlistlist

еще одним преимуществом использования возникают, когда вы добавить или удалить из списка, поскольку эти операции , а они для . обратите внимание, что может быть хорошей альтернативой для добавления и удаления от головы, но это не .

linkedlistarraylistsarraylists

также, если у вас есть большие списки, имейте в виду, что использование памяти тоже разные. каждый элемент имеет больше накладных расходов, поскольку указатели на следующий и предыдущий элементы хранятся. пока нет таких издержек. тем не менее, занимают столько памяти, сколько выделено по мощности, вне зависимости от того, элементы были добавлены.

arraylistarraylist

начальная емкость по умолчанию довольно маленький (10 из java 1.4 - 1.8). но поскольку базовая реализация является массив, то массив должен быть изменен, если вы добавляете много элементов. чтобы избежать больших затрат на изменение размера, когда вы знаете, вы собираетесь добавить много элементов, построить с более высокой начальной емкости.

Ответ 2

linkedlistarraylist

до сих пор, кажется, никто не обратился к памяти каждого из этих списков, к тому же общее мнение, что это "много больше", чем так что я с задачей-показать, сколько именно обоих списках взяться за n пустые ссылки.

linkedlistsarraylists

поскольку ссылки являются либо 32 или 64 бита (даже если нулевой) на свою относительную систем, я включил 4 наборов данных на 32 и 64 бит и .

note:arraylisttrimmed listsarraylist

размеры приведены для линий - в практике, в качестве вспомогательного массива в целом больше, чем его текущее количество элементов.

note 2:(thanks beeonrope)

как compressedoops по умолчанию теперь с середины jdk6 и до значения ниже на 64-разрядных компьютерах будут в основном соответствовать их 32-битные аналоги, если конечно вы специально его не выключите.

linkedlistarraylistlinkedlists

результат ясно показывает, что это намного больше , особенно с очень высокой плотностью элементов. если память-это фактор, подальше от .

формулы я использовал следовать, дайте мне знать, если я сделал что не так и я исправлю это. " б " составляет 4 или 8 для 32 и 64 битных систем, и 'n' - количество элементов. отметим, поводом для модов, потому что все объекты в java будет занимать кратно 8 байт пространства независимо от того, все или нет.

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)

linkedlist:

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)

Ответ 3

arraylistlinkedlist

это то, что вы хотите. почти всегда (выполнение) ошибка.

linkedlist

почему хреново:

it uses lots of small memory objects, and therefore impacts performance across the process.

lots of small objects are bad for cache-locality.

any indexed operation requires a traversal, i.e. has o(n) performance. this is not obvious in the source code, leading to algorithms o(n) slower than if arraylist was used.

getting good performance is tricky.

even when big-o performance is the same as arraylist, it is probably going to be significantly slower anyway.

it's jarring to see linkedlist in source because it is probably the wrong choice.

Ответ 4

как человек, который занимается эксплуатационных характеристик техники на очень крупных веб-сервисов soa около десяти лет, я бы предпочел поведения linkedlist не более класса arraylist. в то время как стационарный производительность linkedlist не хуже, и поэтому может привести к покупке дополнительного оборудования -- поведение arraylist с под давлением может привести к приложениям в кластере расширяют свои массивы в ближайшее синхронность и для больших размеров массива могут привести к недостаточной восприимчивости в приложение и отключения, находясь под давлением, что катастрофическое поведение.

кроме того, вы можете получить лучшую производительность в приложениях по умолчанию пропускная способность ординарный сборщик мусора, но как только вы получите java-приложений 10 гбит / с куч можно заводить замок приложение в течение 25 секунд во время полного нсу, которая приводит к дополнительным задержкам и сбоям в soa приложений и удары д., если это происходит слишком часто. хотя коллектор cms требует больше ресурсов и не достичь того же пропускную способность, она является гораздо лучшим выбором, потому что он более предсказуем и меньше задержки.

arraylist является только лучшим выбором для повышения производительности, если все вы имеете в виду по производительности является пропускная способность и вы можете игнорировать задержку. по моему опыту в моей работе я не могу игнорировать наихудшем случае задержка.

Ответ 5

algorithm           arraylist   linkedlistseek 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)

algorithms: big-oh notation

артефакты arraylist хороши для однократной записи-чтения много или аппендеры, но плохо добавить/удалить из передней или средней.

Ответ 6

да, я знаю, это древний вопрос, но я добавлю свои пять копеек:

almost always

linkedlist не является неверный выбор, производительность-мудрый. есть некоторые очень специфические алгоритмы, где в linkedlist не называется, но это очень, очень редкая и алгоритм, как правило, конкретно зависят от класса linkedlist возможность вставлять и удалять элементы в середину списка относительно быстро, как только вы перешли туда с listiterator.

circulararraylist implementation

есть один распространенный случай использования, в которых linkedlist не превосходит arraylist с: что из очереди. однако, если ваша цель-результативность, вместо linkedlist не следует также рассмотреть возможность использования arrayblockingqueue (если вы можете определить ограничение на размер очереди загодя, и можете позволить себе выделить всю память впереди), или этот . (да, это с 2001 года, так что вам нужно generify это, но я получил сопоставимые показатели показатели, что указаны в статье просто сейчас в последнее время как jvm)

Ответ 7

linkedlistarraylist

это вопрос эффективности. это быстрое добавление и удаление элементов, но медленно получить доступ к определенному элементу. быстро доступа к конкретному элементу, но может быть медленным, чтобы добавить в любой конец, и особенно медленно, чтобы удалить в середине.

array vs arraylist vs linkedlist vs vector linked list

идет более в глубину, как это делает .

Ответ 8

правильные или неправильные: выполните тест локально и решить для себя!

linkedlistarraylist

редактировать/удалить быстрее, в чем .

arraylistarray

, подкрепленные , который должен быть вдвое больше, хуже в большой объем применения.

ниже результат теста блок для каждой операции.грм приводится в наносекундах.

operation                       arraylist                      linkedlist  addall   (insert)               101,16719                      2623,29291 add      (insert-sequentially)  152,46840                      966,62216add      (insert-randomly)      36527                          29193remove   (delete)               20,56,9095                     20,45,4904contains (search)               186,15,704                     189,64,981

вот код:

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

Ответ 9

arraylistlinkedlist

это по сути массив. реализован в виде списка с двойной связью.

getarraylistarraylistlinkedlistaddremove

это довольно ясно. o(1) для , потому что позволяют произвольный доступ с помощью индекса. о(n), потому что он должен найти первый индекс. примечание: существуют различные версии и .

linkedlistlinkedlist

быстрее в добавить и удалить, но медленнее в хорошем. короче говоря, должны быть предпочтительнее, если:

there are no large number of random access of element

there are a large number of add/remove operations

arraylist

=== ===

add(e e)

add at the end of arraylist
require memory resizing cost.
o(n) worst, o(1) amortized

add(int index, e element)

add to a specific index position
require shifting & possible memory resizing cost
o(n)

remove(int index)

remove a specified element
require shifting & possible memory resizing cost
o(n)

remove(object o)

remove the first occurrence of the specified element from this list
need to search the element first, and then shifting & possible memory resizing cost
o(n)

linkedlist

=== ===

add(e e)

add to the end of the list
o(1)

add(int index, e element)

insert at specified position
need to find the position first
o(n)

remove()

remove first element of the list
o(1)

remove(int index)

remove element with specified index
need to find the element first
o(n)

remove(object o)

remove the first occurrence of the specified element
need to find the element first
o(n)

programcreek.comaddremove

вот это фигура ( и первый тип, т. е. добавить элемент в конец списка и удаляет элемент в указанной позиции в списке.):

Ответ 10

джошуа блохом, автором коллекции linkedlist:

does anyone actually use linkedlist? i wrote it, and i never use it.

https://twitter.com/joshbloch/status/583813919019573248

ссылка:

извини за ответ, за то, что не так информативно, как и другие ответы, но я думал, что это будет самое интересное и пояснений.

Ответ 11

arraylistlinkedlistarraylist

случайно можно, а это очень дешево для расширения и удаления элементов. в большинстве случаев, это хорошо.

если вы создали большие списки и измеряется узкое место, вы, вероятно, никогда не придется беспокоиться о разнице.

Ответ 12

add(0)remove(0)linkedlistaddfirst()removefirst()arraylist

если ваш код и использовать и это красивее и методов. в противном случае используйте .

guava immutablelist

и конечно, 's-это ваш лучший друг.

Ответ 13

linkedlistdequedequequeuelinkedlistarraydeque

я знаю, это старый пост, но я честно не могу поверить, что никто не упомянул, что реализует . достаточно посмотреть на методы (и )

Ответ 14

arraylistlinkedlistcopyonwrite-arraylist

вот это большой-о нотации в оба и, а также :

arraylist

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

linkedlist

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)

на основе этих вы должны решить, что выбрать. :)

Ответ 15

tl;drarraylistlinkedlist

благодаря современной компьютерной архитектурой, будет значительно более эффективной практически для любого возможного использования-случае - и поэтому его следует избегать, за исключением очень уникальных и экстремальных случаях.

add(e element)

в теории, linkedlist не имеет о(1) для

также при добавлении элемента в середину списка должна быть очень эффективной.

cache hostilelinkedlistcache-friendlyarraylist

практика очень разная, как linkedlist-это структура данных. от производительности пов - есть очень мало случаев, когда может быть более эффективные, чем .

здесь представлены результаты тестирования производительности, вставка элементов в случайных местах. как вы можете видеть - массив, список, если намного эффективнее, хотя в теории каждая вставка в середину списка требуют "двигаться" на более поздние элементы массива (чем меньше значение, тем лучше):

работая на более поздние поколения оборудования (больше, эффективнее кэширует) - результаты будут еще более убедительными:

source source code

linkedlist не занимает гораздо больше времени, чтобы выполнить ту же работу.

есть две основные причины для этого:

mainly - that the nodes of the linkedlist are scattered randomly across the memory. ram ("random access memory") isn't really random and blocks of memory need to be fetched to cache. this operation takes time, and when such fetches happen frequently - the memory pages in the cache need to be replaced all the time -> cache misses -> cache is not efficient. arraylist elements are stored on continuous memory - which is exactly what the modern cpu architecture is optimizing for.

secondary linkedlist required to hold back/forward pointers, which means 3 times the memory consumption per value stored compared to arraylist.

dynamicintarrayint

кстати, это нестандартная реализация класса arraylist холдинг (примитивного типа), а не объекты - следовательно, все данные действительно хранятся смежно - отсюда еще более эффективным.

ключевым элементов нужно помнить, что стоимость выборки блока памяти, является более значительным, чем стоимость доступа к одной ячейке памяти. вот почему читатель 1мб последовательной памяти до х400 раз быстрее, чем чтение такого количества данных из разных блоков памяти:

latency comparison numbers (~2012)----------------------------------l1 cache reference                           0.5 nsbranch mispredict                            5   nsl2 cache reference                           7   ns                      14x l1 cachemutex lock/unlock                           25   nsmain memory reference                      100   ns                      20x l2 cache, 200x l1 cachecompress 1k bytes with zippy             3,000   ns        3 ussend 1k bytes over 1 gbps network       10,000   ns       10 usread 4k randomly from ssd*             150,000   ns      150 us          ~1gb/sec ssdread 1 mb sequentially from memory     250,000   ns      250 usround trip within same datacenter      500,000   ns      500 usread 1 mb sequentially from ssd*     1,000,000   ns    1,000 us    1 ms  ~1gb/sec ssd, 4x memorydisk seek                           10,000,000   ns   10,000 us   10 ms  20x datacenter roundtripread 1 mb sequentially from disk    20,000,000   ns   20,000 us   20 ms  80x memory, 20x ssdsend packet ca->netherlands->ca    150,000,000   ns  150,000 us  150 ms

latency numbers every programmer should know

источник:

linkedlistarraylist

просто для того, чтобы сказать еще яснее, пожалуйста, проверьте эталоном для добавления элементов в начало списка. это случай, где, в теории, должен действительно сиять, и должны представлять плохое или еще хуже-случай результаты:

source code

примечание: это эталоном с стд либ, но мой предыдущий опыт показал результаты c и java очень похожи.

arraylistvector

копирование последовательный основная память представляет собой оптимизация работы современных процессоров - изменение теории и на самом деле делает, снова, / гораздо эффективнее

kjell hedström his blog

кредиты: все тесты, размещенные здесь создаются . еще больше информации можно найти на

Ответ 16

давайте сравним linkedlist и arraylist вт.р.т. ниже параметры:

1. реализация

arraylist is the resizable array implementation of list interface , while

linkedlist is the doubly-linked list implementation of the list interface.

2. производительности

get(int index) or search operation

arraylist get(int index) operation runs in constant time i.e o(1) while

linkedlist get(int index) operation run time is o(n) .

the reason behind arraylist being faster than linkedlist is that arraylist uses an index based system for its elements as it internally uses an array data structure, on the other hand,

linkedlist does not provide index-based access for its elements as it iterates either from the beginning or end (whichever is closer) to retrieve the node at the specified element index.

insert() or add(object) operation

insertions in linkedlist are generally fast as compare to arraylist. in linkedlist adding or insertion is o(1) operation .

while in arraylist, if the array is the full i.e worst case, there is an extra cost of resizing array and copying elements to the new array, which makes runtime of add operation in arraylist o(n), otherwise it is o(1).

remove(int) operation

remove operation in linkedlist is generally the same as arraylist i.e. o(n).

in linkedlist, there are two overloaded remove methods. one is remove() without any parameter which removes the head of the list and runs in constant time o(1). the other overloaded remove method in linkedlist is remove(int) or remove(object) which removes the object or int passed as a parameter. this method traverses the linkedlist until it found the object and unlink it from the original list. hence this method runtime is o(n).

while in arraylist remove(int) method involves copying elements from the old array to new updated array, hence its runtime is o(n).

3. обратный итератор

linkedlist can be iterated in reverse direction using descendingiterator() while

there is no descendingiterator() in arraylist , so we need to write our own code to iterate over the arraylist in reverse direction.

4. начальная емкость

if the constructor is not overloaded, then arraylist creates an empty list of initial capacity 10, while

linkedlist only constructs the empty list without any initial capacity.

5. память

memory overhead in linkedlist is more as compared to arraylist as a node in linkedlist needs to maintain the addresses of the next and previous node. while

in arraylist each index only holds the actual object(data).

source

Ответ 17

arraylistrandomaccesslinkedlistqueue

в дополнение к другим хорошим выше аргументов, вы должны заметить реализует интерфейс, а реализует .

так что, как-то они решают немного разные задачи, с разницей в эффективности и поведения (см. их перечень методов).

Ответ 18

the java tutorials - list implementations

см .

Ответ 19

я обычно использую один над другим на основе сложности выполнения операций, которые я выполнил бы на этом конкретном списке.

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

Ответ 20

список массива-это по сути массив методов для добавления элементов и т. д. (и вы должны использовать общий список). это коллекция элементов, которые могут быть доступны через индексатор (например, [0]). она подразумевает переход от одного элемента к следующему.

список ссылок определяет переход от одного элемента к следующему (пункт а -> пункт б). вы можете получить тот же эффект со списком массив, а связанный список абсолютно говорит, что деталь должна следовать за предыдущей.

Ответ 21

это зависит от того, какие операции вы будете делать далее по списку.

arraylist

быстрее получить доступ к индексированным значением. гораздо хуже, когда вставка или удаление объектов.

чтобы узнать больше, прочтите любую статью, которая рассказывает о разнице между массивы и связанные списки.

Ответ 22

важной особенностью связанный список (который я не читал в другой ответ) - это конкатенация двух списков. с массивом это о(н) ( накладные некоторого перераспределения) с связанный список это только o(1) или o(2)

importantlinkedlistis there a fast concat method for linked list in java?

: для java его это не правда! см

Ответ 23

я читал ответы, но есть один сценарий, где я всегда использовать linkedlist не более arraylist, который я хочу поделиться, чтобы услышать мнения:

каждый раз, когда у меня был метод, возвращающий список данных, полученных из бд, я всегда использовать linkedlist не.

мое обоснование было, что ведь невозможно точно знать, сколько результаты я получаю, не будет потери памяти (как в arraylist с с разницей между потенциалом и фактическим количеством элементов), и не было бы времени впустую, пытаясь дублировать потенциала.

в коллекцию arraylist, я согласен, что, по крайней мере, вы всегда должны использовать конструктор с начальной емкостью, чтобы свести к минимуму дублирование массивов как можно больше.

Ответ 24

arraylist и linkedlist не имеют свои плюсы и минусы.

класса arraylist использует непрерывные адрес памяти, по сравнению с класса linkedlist, который использует указатели на следующий узел. так что если вы хотите, чтобы найти элемент в arraylist будет быстрее, чем делать итераций n с linkedlist не.

с другой стороны, вставки и удаления в linkedlist не намного легче, потому что вы просто должны изменить указатели в то время как объект arraylist предполагает использование операции сдвига для вставки или удаления.

если у вас частые операции поиска в своем приложении использовать arraylist. если у вас частые вставки и удаления использовать linkedlist не.

Ответ 25

arraylistlinkedlistlist interface

и как реализованы их методы и результаты практически идентичны. однако существует несколько различий между ними, которые делают одну за другой в зависимости от требования.

класса arraylist против linkedlist не

search:arraylistlinkedlistget(int index)arraylisto(1)linkedlisto(n)

1) поисковая операция довольно быстро по сравнению с поисковой операции. дает производительность а производительность .

reason:arraylistlinkedlist

система сохраняет индекс для ее элементов, как он использует массив структура данных неявно, что делает его быстрее для поиска элемента в списке. с другой стороны реализует двусвязный список, который требует прохождения через все элементы поиск элемента.

deletion:linkedlisto(1)arraylisto(n)o(1)

2) удалить операция дает производительность, дает переменную производительность: в худшем случае (при удалении первого элемента) и в лучшем случае (при удалении последнего элемента).

conclusion: linkedlist element deletion is faster compared to arraylist.

причина: каждый элемент linkedlist не поддерживает двух указателей (адресов), который указывает на обе соседние элементы в списке. отсюда требуется для удаления только изменения в расположении указателя в двух соседних узлов (элементов) узел, который будет удален. хотя в коллекции все элементы должны быть смещены, чтобы заполнить пространство, созданное удален элемент.

inserts performance:linkedlisto(1)arraylisto(n)

3) добавить метод дает представление, а дает в худшем случае. причина такой же, как описано для удалять.

memory overhead:arraylistlinkedlist

4) поддерживает состояние индексов и данных элемента, в то время как сохраняет элемент данных и два указателя на соседние узлы

hence the memory consumption is high in linkedlist comparatively.

есть несколько сходств между этими классами которых являются следующие:

both arraylist and linkedlist are implementation of list interface.

they both maintain the elements insertion order which means while displaying arraylist and linkedlist elements the result set would be having the same order in which the elements got inserted into the list.

both these classes are non-synchronized and can be made synchronized explicitly by using collections.synchronizedlist method.

the iterator and listiterator returned by these classes are fail-fast (if list is structurally modified at any time after the iterator is created, in any way except through the iterator’s own remove or add methods, the iterator will throw a concurrentmodificationexception).

когда использовать linkedlist и когда использовать arraylist?

as explained above the insert and remove operations give good performance (o(1)) in linkedlist compared to arraylist(o(n)).

hence if there is a requirement of frequent addition and deletion in application then linkedlist is a best choice.

search (get method) operations are fast in arraylist (o(1)) but not in linkedlist (o(n))

so if there are less add and remove operations and more search operations requirement, arraylist would be your best bet.

Ответ 26

arraylist:
linkedlist:

операцию get(i) в arraylist является быстрее, чем связанный список linkedlist, потому что: изменяемого размера массива реализации интерфейса list, реализация двунаправленного связанного списка list и deque интерфейсы

операций, что индекс в списке обхода списка от начала или конца, в зависимости от того ближе к указанному индексу.

Ответ 27

1) underlying data structure

первая разница между arraylist и linkedlist не идет с тем, что arraylist поддерживается массива, а linkedlist не поддерживается linkedlist не. это приведет к дальнейшему различия в производительности.

2) linkedlist implements deque

еще одно различие между arraylist и linkedlist не является то, что кроме интерфейса list, linkedlist также реализует интерфейс дека, которая обеспечивает первые в первых операциях для добавить() и poll() и несколько других функций двухсторонней очереди. 3) добавление элементов в коллекцию arraylist при добавлении элемента в arraylist является o(1) операция, если он не запускает изменить размер массива, в этом случае он станет o(лог(н)), с другой стороны, добавление элемента в связанный список linkedlist является o(1) операция, так как он не требует каких-либо переходов.

4) removing an element from a position

для того, чтобы удалить элемент из определенного индекса, например, путем вызова удалить(индекс) класса arraylist выполняет операцию копирования, который делает его близко к o(n), а linkedlist не должен пройти до этой точки, что также делает его o(н/2), так как он может передвигаться в любом направлении, основываясь на близости.

5) iterating over arraylist or linkedlist

итерация-это о(n) операций для linkedlist и arraylist, где n-номер элемента.

6) retrieving element from a position

получить(индекс) операции есть o(1) в arraylist с а о(н/2) в linkedlist не, как он должен пройти до этой записи. хотя, в биг-о'нотации о(н/2) всего за o(n), так мы игнорируем константы.

7) memory

linkedlist не использует объект-оболочку, запись, которая является статический вложенный класс для хранения данных и двумя узлами и в то время как коллекции просто хранит данные в массиве.

поэтому требования к памяти, кажется, меньше в случае класса arraylist linkedlist не чем за исключением случая, когда массив выполняет изменение размера операции, когда он копирует контент с одного массива на другой.

если массив достаточно большой, это может занять много памяти на ссылки и запустить сбор мусора, который может замедлить время отклика.

из всего выше различия между класса arraylist против linkedlist не, это выглядит arraylist является лучшим выбором, чем linkedlist в почти всех случаях, кроме случаев, когда вы часто добавить() операции, чем удалить () или get().

легче изменить список ссылок, чем arraylist, в особенности, если вы добавлять или удалять элементы из начала или конца, потому что связанный список хранит ссылки на эти посты и они доступны в o(1) времени.

другими словами, вам не нужно проходить через связанный список, чтобы достичь позиции, где вы хотите, чтобы добавить элементы, в этом случае, дополнение станет o(n) операций. например, вставка или удаление элемента в середину списка.

на мой взгляд, использовать arraylist linkedlist не более для большинства практических целей в java.

Ответ 28

как удалить() и insert() имеют эффективность выполнения порядка o(n) для обоих артефакты arraylist и linkedlists. однако, причина за линейное время обработки поступает из двух весьма различных причин:

в arraylist, вы получите элемент за o(1), но на самом деле, чтобы положить или взять что-то делает это за o(n), потому все следующие элементы должны быть изменены.

в linkedlist не, это занимает o(n), чтобы фактически добраться до нужного элемента, потому что мы должны начать с самого начала, пока мы не достигнем желаемого индекса. на самом деле удаление или вставка является постоянным, потому что у нас только изменить 1 ссылка на удалить() и 2 ссылки для вставки().

какой из двух быстрее для установки и удаления зависит от того, где это происходит. если мы ближе к началу класса linkedlist будет быстрее, потому что мы должны пройти через относительно небольшое число элементов. если мы ближе к концу списка arraylist будет быстрее, потому что у нас есть в постоянное время и изменить некоторые остальные элементы, следующие за ним. когда это сделано точно в середине класса linkedlist будет быстрее, потому что пройдя через n элементов происходит быстрее, чем перемещение n значений.

бонус: в то время как нет никакого способа, что делает эти два метода o(1) для объекта arraylist, там на самом деле есть способ сделать это в linkedlists. скажем, мы хотим, чтобы пройти через весь список, удаление и вставка элементов на нашем пути. обычно, вы начнете с самого начала для каждого элемента с помощью linkedlist не, мы могли бы также "сохранить" текущий элемент мы работаем с итератором. с помощью итератора, мы получим о(1) эффективность удаления() и insert() при работе в linkedlist не. делая это только на пользу производительности я в курсе, где linkedlist не всегда лучше, чем arraylist.

Ответ 29

arraylist.get()linkedlist.get()
arraylist.add()linkedlist.add()
arraylist.contains()linkedlist.contains()
arraylist.next()linkedlist.next()
arraylist.remove()linkedlist.remove()

iterator.remove()

iterator.remove()

коллекция arraylist расширяет abstractlist и реализует интерфейс list. arraylist является динамический массив.можно сказать, что он был в основном создан, чтобы преодолеть недостатки arraysthe класс linkedlist не распространяется abstractsequentiallist и список инвентаря,очереди, и очередь интерфейс.производительность составляет o(1), тогда как о(п) является o(1) и 0(1) о(п) и о(n) есть o(1) и равна o(1) o(п), а за o(1)в arraylist является o(п), тогда как в linkedlist не является o(1)