Choosing a Collections Class


  • If you’re coming to Scala from Java, forget the Java collections classes. Using them will just slow you down.
  • Vector and ArrayBuffer are your “go to” sequence types.

Immutable vs Mutable

The collections types can be classified as immutable (unchangeable) and mutable:

  • Immutable type are available by default (Vector, List, and the immutable Map and Set)
    • Immutable is preferred (always use immutable, unless there’s a good reason not to)
  • Mutable types have to be imported to use them

Sequences are Indexed or Linear

Sequence types can also be classified as indexed or linear:

  • Indexed
    • Fast, random access to elements
    • Vector, Seq, ArrayBuffer
  • Linear
    • i.e., a linked list (List)
    • Random access is slow

The “Go To” (common) data types

  • Vector and ArrayBuffer are the preferred sequence types.
  • List is also okay for small, immutable sequences (or when you are prepending elements and accessing the head and tail components).
Immutable     |  Mutable
List, Vector  |  ArrayBuffer
Map           |  Map
Set           |  Set

Common types

  • Vector is an immutable, indexed sequence
  • List is an immutable, linear sequence
  • ArrayBuffer is a mutable, indexed sequence
  • We use other types like Map, Set, Range, and tuples all the time.


  • There is an Array, which wraps the Java array, but we don’t really use it directly (use ArrayBuffer instead)

When returning types from functions:

  • Seq implies immutable
  • IndexedSeq implies immutable, indexed

Creating collections instances is very consistent:

val a = Vector(1, 2, 3)
val b = List(1, 2, 3)
val c = ArrayBuffer(1, 2, 3)
val d = Set(1, 1, 1, 2, 2, 2, 3)
val e = Map(1 -> "a", 2 -> "b")

Using them in for expressions is also consistent, as are append, prepend, update, and delete methods. (See the Vector and ArrayBuffer videos for examples.)


  • A Map is a list of key/value pairs, where the keys are unique.
  • The immutable Map is available by default.
  • You have to import the mutable Map if you want to use it.
val a = Map("a" -> 1, "b" -> 2)
val m = Map(
    "first_name" -> "Alvin",
    "last_name"  -> "Alexander"


  • A Set is a collection of unique elements.
  • The immutable Set is available by default.
  • You have to import the mutable Set if you want to use it.
val set = Set(1, 1, 2, 2, 3, 3, 3)
// result: Set(1, 2, 3)


  • A Range is a sequence of equally spaced values.
  • Typically created with to (and until).
1 to 10
1 to 10 by 2

'a' to 'e'
'a' to 'e' by 2

for i <- 1 to 10 yield i * 10


  • Not really a collection class, but similar.
  • A heterogenous collection of values.
(1, 2.2, 3L, 'a', "yo")    // (Int, Double, Long, Char, String)

val t = (1, 2.2, 3L, 'a', "yo")

def getUserInfo(): (String, Int, Double) =
    // do some stuff here, then return a 3-element tuple
    ("Al", 42, 200.0)

val (name, age, weight) = getUserInfo()

See the “Tuples” video for more details.

More resources

Detailed blog posts on my website, with hundreds of examples: