Ответ 1
summary
arraylist
arraydeque
many
linkedlist
arraylist с предпочтительнее, чем больше дел, чем . если вы не уверены — просто начать .
linkedlist
arraylist
linkedlist
arraylist и две различные реализации интерфейса 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/4
o(1)
index = 0 обеспечивает постоянное время вставки и удаления , но только последовательный доступ к элементам. другими словами, вы можете пройтись по списку вперед или назад, но найти позицию в списке занимает время, пропорциональное размеру списка. у javadoc говорит , поэтому эти методы ( действия) в среднем, хотя для .
arraylist<e>
arraylist
o(n) с другой стороны, позволит быстрый произвольный доступ на чтение, так что вы можете захватить любой элемент в постоянное время. а добавив или удалив из любой точки мира, но конец требует переложив все последние элементы, либо сделать проем или заполнить пробел. также, если вы добавить больше элементов, чем емкость основной массив, новый массив (в 1.5 раза), и старого массива копируются в новый, чтобы добавить к это, в худшем случае, но постоянный в среднем.
arraylist поэтому в зависимости от операций, которые вы собираетесь делать, вы должны выбрать соответственно реализации. перебора либо вид списка практически одинаково дешево. (повторяя за технически быстрее, но если вы делаете что-то очень чувствительные к производительности, вы не должны беспокоиться об этом-они обе константы.)
linkedlist
o(1)
moved
linkedlist
o(n)
n/2
arraylist
o(1) основные преимущества использования возникают, когда вы повторно использовать существующие итераторы вставки и удаления элементов. эти операции могут быть выполнены в результате изменения списка только локально. в список массива, в оставшейся части массива, который должен быть (т. е. копируются). с другой стороны, ищет в средства по ссылкам в ( шагов) в худшем случае, а в нужном положении может быть математически рассчитаны и доступны в .
linkedlist
o(1)
o(n)
arraylist
arraydeque
linkedlist
list еще одним преимуществом использования возникают, когда вы добавить или удалить из списка, поскольку эти операции , а они для . обратите внимание, что может быть хорошей альтернативой для добавления и удаления от головы, но это не .
linkedlist
arraylists
arraylists также, если у вас есть большие списки, имейте в виду, что использование памяти тоже разные. каждый элемент имеет больше накладных расходов, поскольку указатели на следующий и предыдущий элементы хранятся. пока нет таких издержек. тем не менее, занимают столько памяти, сколько выделено по мощности, вне зависимости от того, элементы были добавлены.
arraylist
arraylist начальная емкость по умолчанию довольно маленький (10 из java 1.4 - 1.8). но поскольку базовая реализация является массив, то массив должен быть изменен, если вы добавляете много элементов. чтобы избежать больших затрат на изменение размера, когда вы знаете, вы собираетесь добавить много элементов, построить с более высокой начальной емкости.
Ответ 2
linkedlist
arraylist до сих пор, кажется, никто не обратился к памяти каждого из этих списков, к тому же общее мнение, что это "много больше", чем так что я с задачей-показать, сколько именно обоих списках взяться за n пустые ссылки.
linkedlists
arraylists поскольку ссылки являются либо 32 или 64 бита (даже если нулевой) на свою относительную систем, я включил 4 наборов данных на 32 и 64 бит и .
note:
arraylist
trimmed lists
arraylist размеры приведены для линий - в практике, в качестве вспомогательного массива в целом больше, чем его текущее количество элементов.
note 2:
(thanks beeonrope) как compressedoops по умолчанию теперь с середины jdk6 и до значения ниже на 64-разрядных компьютерах будут в основном соответствовать их 32-битные аналоги, если конечно вы специально его не выключите.
linkedlist
arraylist
linkedlists результат ясно показывает, что это намного больше , особенно с очень высокой плотностью элементов. если память-это фактор, подальше от .
формулы я использовал следовать, дайте мне знать, если я сделал что не так и я исправлю это. " б " составляет 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 pre class='grey lighten-3 px-3 mb-0 line-numbers language-html'vious 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)