Arrays scala中数组和列表的区别

在什么情况下我应该使用数组（缓冲区）和列表（缓冲区）。我所知道的唯一区别是数组是非变量的，列表是协变的。但是性能和其他一些特性呢

不变结构 Scala

列表

是一种不可变的递归数据结构，它是Scala中的一种基本结构，您应该（可能）使用它，而不是使用

数组

（它实际上是可变的，

数组

的不可变模拟是

IndexedSeq

）

如果您来自Java背景，那么最明显的相似之处是何时使用

LinkedList

而不是

ArrayList

。前者通常用于仅被遍历过的列表（其大小事先未知），而后者应用于具有已知大小（或最大大小）或快速随机访问非常重要的列表

可变结构

ListBuffer

提供了到

List

的恒定时间转换，这是使用

ListBuffer

的唯一原因，如果需要以后的转换

scala

数组

应该通过Java数组在JVM上实现，因此

数组[Int]

的性能（作为

Int[]

）可能比

列表[Int]

（列表[Int]的性能要好得多，除非您使用的是最新版本的scala，它具有新的

@专用的

功能）

---

然而，我认为Scala中

数组

s的使用应该保持在最低限度，因为感觉您真的需要知道引擎盖下发生了什么，以决定您的数组是否真正由所需的原语类型支持，或者是否可以作为包装器类型装箱

数组是可变的，这意味着您可以更改每个索引的值，而列表（默认情况下）是不可变的，这意味着您每次进行修改时都会创建一个新列表。在大多数情况下，处理不可变的数据类型是一种更“功能性”的风格，您可能应该尝试使用一个包含诸如

yield

、

foreach

、

match

等结构的列表

---

对于性能特征，数组在随机访问元素时速度更快，而列表在预先添加新元素时速度更快。迭代它们是可比较的

除了已经发布的答案，这里还有一些细节

虽然

数组[A]

实际上是一个Java数组，

列表[A]

是一个不可变的数据结构，它要么是

Nil

（空列表），要么由一对

（A，列表[A]）

组成

性能差异

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

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

记忆差异

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

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

---

因此，除非您需要快速随机访问，需要计算元素，或者出于某种原因需要破坏性更新，

列表

优于

数组

@leonm-apols，否则我认为OP只询问*缓冲区类，我意识到他们也询问“正常”类！附加到ArrayBuffer通常比预先附加到列表（或将元素添加到ListBuffer）更快，因为列表需要创建包装器对象，而ArrayBuffer只需要将对象（平均大约两次）复制到新数组。两个副本通常比一个对象创建快，因此ArrayBuffer通常在Beats列表PrimeDead中执行。当“代码>重复< < /代码> >时，数组的执行速度比列表快得多，这是因为CaseHew看到的，并且数组的“相等”的定义是指相同的数组，这些OS必须考虑复制列表的时间吗？我假设您正在这样做测试，例如：

list=list.drop（I）

。或者，在引擎盖后面会发生一些神奇的事情吗？这需要考虑在必要时复制列表和数组。请注意，

drop

之类的操作永远不需要复制列表中未删除的部分。例如，

（x：：xs）。drop（1）

正是

xs

，而不是

xs

的“副本”。这些渐近性与Scala无关。C中相同的数据结构在常数因子上的速度将完全相同。@Apocalisp您是否有参考或在什么条件下确定此信息？@Phil这些是渐近的，不是测量值。它们在任何情况下都适用。