Разница между массивом и списком в Scala

Question

Разница между массивом и списком в Scala

94

В каких случаях я должен использовать Array (Buffer) и List (Buffer). Единственное отличие, которое я знаю, это то, что массивы невариантны, а списки ковариантны. Но как насчет производительности и некоторых других характеристик?

Jeriho 26 апр. 2010, в 11:28

Источник

Теги:

arrays

list

scala

scala-collections

3 ответа

95

В дополнение к уже опубликованным ответам, вот некоторые особенности.

Хотя Array[A] является буквально массивом Java, List[A] - это неизменяемая структура данных, которая либо является Nil (пустой список), либо состоит из пары (A, List[A]).

Различия в производительности

                          Array  List
Access the ith element    O(1)   O(i)
Delete the ith element    O(n)   O(i)
Insert an element at i    O(n)   O(i)
Reverse                   O(n)   O(n)
Concatenate (length m,n)  O(n+m) O(n)
Count the elements        O(1)   O(n)

Различия в памяти

                          Array  List
Get the first i elements  O(i)   O(i)
Drop the first i elements O(n-i) O(1)
Insert an element at i    O(n)   O(i)
Reverse                   O(n)   O(n)
Concatenate (length m,n)  O(n+m) O(n)

Поэтому, если вам не нужен быстрый случайный доступ или необходимость подсчета элементов, List лучше, чем Array.

Apocalisp 26 апр. 2010, в 12:49

0

Должны ли эти ОС учитывать время для копирования Списка? Я предполагаю, что вы делаете тест, как это, например: list = list.drop(i) . Или происходит какая-то магия за капотом?
user445107 14 янв. 2013, в 14:10
2

При этом учитывается копирование списков и массивов при необходимости. Обратите внимание, что такие вещи, как drop никогда не должны копировать ту часть списка, которая не была удалена. Например, (x::xs).drop(1) - это ровно xs , а не «копия» xs .
Apocalisp 14 янв. 2013, в 15:05
0

Ужасные сложности «Перевернуть» и «Объединить» для списков… в C вы можете легко получить O (1) сложность. Я уверен, что то же самое верно, если это было правильно реализовано в Scala>. <
A T 07 окт. 2013, в 10:10
6

Эти асимптотики не имеют ничего общего со Scala. Та же самая структура данных в C будет точно такой же быстрой, вплоть до постоянных факторов.
Apocalisp 07 окт. 2013, в 15:54
0

Есть еще одно принципиальное различие в памяти: Array содержит одну ссылку для каждого элемента, где List содержит две - одну для элемента и одну для остальной части списка. Для примитивных типов это означает вдвое большее потребление памяти только для хранения в памяти.
icl7126 06 июнь 2016, в 06:34
1

@Apocalisp У вас есть ссылка или на каких условиях вы определили эту информацию?
Phil 18 июнь 2016, в 18:52
1

@Phil Это асимптотика, а не измерения. Они сохранятся в любых условиях.
Apocalisp 19 июнь 2016, в 03:15
0

@ icl7126 Небольшой постоянный коэффициент не является принципиальной разницей с моей точки зрения.
Apocalisp 22 авг. 2018, в 13:52

Показать ещё 6 комментариев

13

Array изменен, что означает, что вы можете изменять значения каждого индекса, тогда как список (по умолчанию) является неизменным, что означает, что новый список создается каждый раз, когда вы делаете модификацию. В большинстве случаев это более "функциональный" стиль для работы с неизменяемыми типами данных, и вам следует, вероятно, попробовать использовать List с конструкциями типа yield, foreach, match и т.д.

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

leonm 26 апр. 2010, в 11:53

0

ListBuffer является изменяемым
oxbow_lakes 26 апр. 2010, в 11:21
0

@leonm - apols, я думал, что ОП спрашивал исключительно о классах * Buffer, я понимаю, что они также спрашивали о «нормальных» классах!
oxbow_lakes 26 апр. 2010, в 11:35
1

Обычно быстрее добавить к ArrayBuffer, чем добавить к списку (или добавить элемент к ListBuffer), поскольку списки требуют создания объекта-оболочки, в то время как ArrayBuffer просто нужно скопировать объект (в среднем около двух раз) в новый массив , Две копии обычно быстрее, чем создание одного объекта, поэтому ArrayBuffer append обычно превосходит List prepend.
Rex Kerr 26 апр. 2010, в 20:16
0

@oxbow_lakes не беспокойся :-)
leonm 27 апр. 2010, в 10:48
0

массив выполняет гораздо быстрее , чем список , когда iterate over , из кэша
Bin 13 дек. 2016, в 03:07

Показать ещё 3 комментария

Ещё вопросы

Должны ли эти ОС учитывать время для копирования Списка? Я предполагаю, что вы делаете тест, как это, например: list = list.drop(i) . Или происходит какая-то магия за капотом?
При этом учитывается копирование списков и массивов при необходимости. Обратите внимание, что такие вещи, как drop никогда не должны копировать ту часть списка, которая не была удалена. Например, (x::xs).drop(1) - это ровно xs , а не «копия» xs .
Ужасные сложности «Перевернуть» и «Объединить» для списков… в C вы можете легко получить O (1) сложность. Я уверен, что то же самое верно, если это было правильно реализовано в Scala>. <
Эти асимптотики не имеют ничего общего со Scala. Та же самая структура данных в C будет точно такой же быстрой, вплоть до постоянных факторов.
Есть еще одно принципиальное различие в памяти: Array содержит одну ссылку для каждого элемента, где List содержит две - одну для элемента и одну для остальной части списка. Для примитивных типов это означает вдвое большее потребление памяти только для хранения в памяти.
@Apocalisp У вас есть ссылка или на каких условиях вы определили эту информацию?
@Phil Это асимптотика, а не измерения. Они сохранятся в любых условиях.
@ icl7126 Небольшой постоянный коэффициент не является принципиальной разницей с моей точки зрения.
@leonm - apols, я думал, что ОП спрашивал исключительно о классах * Buffer, я понимаю, что они также спрашивали о «нормальных» классах!
Обычно быстрее добавить к ArrayBuffer, чем добавить к списку (или добавить элемент к ListBuffer), поскольку списки требуют создания объекта-оболочки, в то время как ArrayBuffer просто нужно скопировать объект (в среднем около двух раз) в новый массив , Две копии обычно быстрее, чем создание одного объекта, поэтому ArrayBuffer append обычно превосходит List prepend.
массив выполняет гораздо быстрее , чем список , когда iterate over , из кэша

oxbow_lakes · Accepted Answer · 2010-04-26T11-38-00.000Z

Неизменяемые структуры

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

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

Изменчивые структуры

ListBuffer обеспечивает постоянное преобразование в List, которое является основанием для использования ListBuffer, если требуется такое последующее преобразование.

A Scala Array должен быть реализован на JVM с помощью массива Java, и, следовательно, Array[Int] может быть намного более результативным (как int[]), чем a List[Int] (который будет включать его содержимое, если вы не используете самые последние версии Scala, у которых есть новая функция @specialized).

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

также см. stackoverflow.com/questions/3213368/… и stackoverflow.com/questions/2481149/… определение «равно» для массивов состоит в том, что они ссылаются на один и тот же массив