Scala for Backend Engineering & Functional Programming · Lesson

Immutable Collections Deep Dive

Explore fundamental immutable collections like List, Map, Set, and learn their efficient usage.

Immutable Collections Deep Dive is a free Scala for Backend Engineering & Functional Programming lesson on CoddyKit — lesson 1 of 3. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Scala for Backend Engineering & Functional Programming learning path, one of 3 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Immutable Collections: Overview

Welcome to immutable collections! In Scala, these are foundational for writing robust, concurrent, and predictable code, especially in functional programming.

We'll explore fundamental types like List, Map, and Set, focusing on their efficient and safe usage.

Why Immutability Matters

Immutability means that once a collection is created, it cannot be changed. Any operation that seems to 'modify' it actually returns a new collection.

Predictability: Easier to reason about code.
Thread Safety: No need for locks as data never changes.
No Side Effects: Operations won't unexpectedly alter data elsewhere.

Scala Lists: Ordered Sequences

A List in Scala is an immutable, ordered sequence of elements of the same type. It's ideal for sequential data where order matters.

You can create a list by simply enumerating its elements.

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4, 5)
    val fruits = List("apple", "banana", "cherry")
    println(s"Numbers list: $numbers")
    println(s"Fruits list: $fruits")
  }
}

List Operations: Head, Tail, Cons

Lists offer common operations like getting the head (first element) and tail (rest of the list). The :: (cons) operator is used to prepend an element, creating a new list.

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(10, 20, 30)
    println(s"Original list: $numbers")
    println(s"Head of list: ${numbers.head}") // 10
    println(s"Tail of list: ${numbers.tail}") // List(20, 30)
    val newList = 5 :: numbers // Prepend 5
    println(s"List with 5 prepended: $newList")
  }
}

Scala Maps: Key-Value Associations

A Map is an immutable collection that stores key-value pairs. Each key is unique and maps to a single value. Maps are excellent for looking up values by a specific key.

object Main {
  def main(args: Array[String]): Unit = {
    val ages = Map("Alice" -> 30, "Bob" -> 25, "Charlie" -> 35)
    val codes = Map(1 -> "One", 2 -> "Two")
    println(s"Ages map: $ages")
    println(s"Codes map: $codes")
  }
}

Map Operations: Access & Update

You can access values in a Map using its key. To 'update' or 'add' a key-value pair, you create a new map with the changes, leaving the original map untouched.

object Main {
  def main(args: Array[String]): Unit = {
    val ages = Map("Alice" -> 30, "Bob" -> 25)
    println(s"Original ages: $ages")
    println(s"Bob's age: ${ages("Bob")}")
    val updatedAges = ages + ("Charlie" -> 35) // Add new pair
    println(s"Ages after adding Charlie: $updatedAges")
    val changedAges = updatedAges + ("Alice" -> 31) // Update Alice's age
    println(s"Ages after updating Alice: $changedAges")
  }
}

Scala Sets: Unique Elements

A Set is an immutable collection of unique elements. Unlike Lists, the order of elements in a Set is not guaranteed, and duplicate elements are automatically ignored.

Sets are perfect for checking membership or ensuring uniqueness.

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = Set(1, 2, 2, 3, 4, 3, 5)
    val letters = Set('a', 'b', 'a')
    println(s"Unique numbers: $numbers")
    println(s"Unique letters: $letters")
  }
}

Set Operations: Add, Remove, Union

Similar to Lists and Maps, operations on Sets like adding or removing elements also return a new Set. You can also perform set theory operations like union (combining sets).

object Main {
  def main(args: Array[String]): Unit = {
    val setA = Set(1, 2, 3)
    val setB = Set(3, 4, 5)
    println(s"Set A: $setA")
    println(s"Set B: $setB")
    val addedSet = setA + 4 // Add element
    println(s"Set A + 4: $addedSet")
    val removedSet = setA - 2 // Remove element
    println(s"Set A - 2: $removedSet")
    val unionSet = setA union setB // Combine sets
    println(s"Set A union Set B: $unionSet")
  }
}

Immutability: Original Remains

It's crucial to remember that all 'modifying' operations on Scala's immutable collections return a new collection. The original collection is never changed.

This behavior is a cornerstone of functional programming in Scala.

object Main {
  def main(args: Array[String]): Unit = {
    val originalList = List(10, 20, 30)
    println(s"Original List: $originalList")
    val doubledList = originalList.map(_ * 2) // map returns a NEW list
    println(s"List after map: $doubledList")
    println(s"Original list is still: $originalList") // Unchanged!
  }
}

Check Your Understanding

Consider the following Scala code snippet:

val mySet = Set(1, 2, 3)
val newSet = mySet + 3 + 4
val finalSet = newSet - 2

What will be the value of mySet after these operations?

Recap: Immutable Collections

You've taken a deep dive into Scala's fundamental immutable collections:

Lists: Ordered sequences, good for sequential data.
Maps: Key-value pairs, efficient for lookups.
Sets: Unique elements, great for membership checks.

The key takeaway is immutability: operations always return new collections, ensuring predictability and safety.

Frequently asked questions

Is the “Immutable Collections Deep Dive” lesson free?

Yes — the full text of “Immutable Collections Deep Dive” is free to read here on the web, and the Scala for Backend Engineering & Functional Programming course includes 3 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Scala for Backend Engineering & Functional Programming course, upgrade to CoddyKit PRO.

What will I learn in “Immutable Collections Deep Dive”?

Explore fundamental immutable collections like List, Map, Set, and learn their efficient usage. You practise Scala for Backend Engineering & Functional Programming with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Scala for Backend Engineering & Functional Programming?

No prior experience is required. Scala for Backend Engineering & Functional Programming on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 3, so you can start here or from the beginning and move at your own pace.

How long does the “Immutable Collections Deep Dive” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Scala for Backend Engineering & Functional Programming lesson?

Yes. Every Scala for Backend Engineering & Functional Programming lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Scala for Backend Engineering & Functional Programming