In what cases I should use Array(Buffer) and List(Buffer). Only one difference that I know is that arrays are nonvariant and lists are covariant. But what about performance and some other characteristics?
+8
A:
Immutable Structures
The Scala List is an immutable recursive data structure which is such a fundamental structure in Scala, that you should (probably) be using it much more than an Array (which is actually mutable - the immutable analog of Array is IndexedSeq).
If you are coming from a Java background, then the obvious parallel is when to use LinkedList over ArrayList. The former is generally used for lists which are only ever traversed (and whose size is not known upfront) whereas the latter should be used for lists which either have a known size (or maximum size) or for which fast random access is important.
Mutable Structures
ListBuffer provides a constant-time conversion to a List which is reason alone to use ListBuffer if such later conversion is required.
A scala Array should be implemented on the JVM by a Java array, and hence an Array[Int] may be much more performant (as an int[]) than a List[Int] (which will box its contents, unless you are using the very latest versions of Scala which have the new @specialized feature).
However, I think that the use of Arrays in Scala should be kept to a minimum because it feels like you really need to know what is going on under the hood to decide whether your array really will be backed by the required primitive type, or may be boxed as a wrapper type.
oxbow_lakes
2010-04-26 11:17:41
also see http://stackoverflow.com/questions/3213368/strange-behaviour-of-the-array-typeand http://stackoverflow.com/questions/2481149/why-does-array0-1-2-array0-1-2-not-return-the-expected-resultthe definition of "equals" for Arrays is that they refer to the same array
oluies
2010-07-09 18:42:44
+4
A:
An Array is mutable, meaning you can change the values of each index, while a List (by default) is immutable, meaning that a new list is created every time you do a modification. In most cases it is a more "functional" style to work with immutable datatypes and you should probably try and use a List with constructs like yield, foreach, match and so forth.
For performance characteristics, an Array is faster with random access to elements, whereas a List is faster when prepending (adding) new elements. Iterating over them is comparable.
leonm
2010-04-26 11:19:55
@leonm - apols, I thought the OP was asking exclusively about the *Buffer classes, I realize that they were also asking about the "normal" ones!
oxbow_lakes
2010-04-26 11:35:02
It's usually faster to append to an ArrayBuffer than to prepend to a List (or add an element to a ListBuffer) since lists require the creation of a wrapper object while ArrayBuffer merely needs to copy the object (on average about twice) to a new array. Two copies are usually faster than one object creation, so ArrayBuffer append usually beats List prepend.
Rex Kerr
2010-04-26 20:16:05
+8
A:
In addition to the answers posted already, here are some specifics.
While an Array[A] is literally a Java array, a List[A] is an immutable data structure that is either Nil (the empty list) or consists of a pair (A, List[A]).
Performance differences
Access the ith element - Array: O(1) - List: O(i)
Discard the ith element - Array: O(n) - List: O(i)
Insert an element at i - Array: O(n) - List: O(i)
Reverse - Array: O(n) - List: O(n)
Calculate the length - Array: O(1) - List: O(n)
Memory differences
Get the first i elements - Array: O(i) - List: O(i)
Drop the first i elements - Array: O(n-i) - List: O(1)
Insert an element at i - Array: O(n) - List: O(i)
Reverse - Array: O(n) - List: O(n)
Apocalisp
2010-04-26 12:44:22