Scala Arrays

An array is a fixed-size, mutable collection where every element has the same type and every position is accessible by index in constant time. Arrays in Scala map directly to Java arrays under the hood, making them the fastest collection for index-based access and interoperability with Java libraries.

Creating Arrays

val scores = Array(85, 92, 78, 95, 88)
val names  = Array("Alice", "Bob", "Carol")
val flags  = Array(true, false, true)
val empty  = Array.empty[Int]                // Array()
val zeros  = Array.fill(5)(0)               // Array(0, 0, 0, 0, 0)
val indices = Array.tabulate(5)(i => i * i) // Array(0, 1, 4, 9, 16)
val range  = Array.range(1, 6)              // Array(1, 2, 3, 4, 5)

Accessing Elements

val fruits = Array("Apple", "Banana", "Cherry", "Date", "Elderberry")

println(fruits(0))    // Apple     (first element)
println(fruits(2))    // Cherry    (third element)
println(fruits.last)  // Elderberry
println(fruits.head)  // Apple
println(fruits.length) // 5

// Negative index — not allowed in Scala (unlike Python)
// fruits(-1) throws ArrayIndexOutOfBoundsException

Index:  0        1        2        3        4
Value: Apple  Banana  Cherry   Date   Elderberry

Modifying Elements

Arrays are mutable — you can change any element by index:

val temps = Array(30, 28, 32, 27, 35)
println(temps(2))   // 32

temps(2) = 25   // change element at index 2
println(temps(2))   // 25
println(temps.mkString(", "))   // 30, 28, 25, 27, 35

Iterating Over Arrays

val grades = Array(90, 75, 88, 62, 95)

// for loop
for grade <- grades do println(grade)

// foreach
grades.foreach(g => println(if g >= 80 then s"$g ✓" else s"$g ✗"))

// for with index
for (grade, i) <- grades.zipWithIndex do
  println(s"Student ${i + 1}: $grade")

Array Operations

val nums = Array(3, 1, 4, 1, 5, 9, 2, 6)

nums.sorted          // Array(1, 1, 2, 3, 4, 5, 6, 9)
nums.sortWith(_ > _) // Array(9, 6, 5, 4, 3, 2, 1, 1)  — descending
nums.sum             // 31
nums.max             // 9
nums.min             // 1
nums.length          // 8
nums.distinct        // Array(3, 1, 4, 5, 9, 2, 6)  — removes duplicates
nums.reverse         // Array(6, 2, 9, 5, 1, 4, 1, 3)
nums.contains(5)     // true
nums.count(_ > 4)    // 3

Slicing Arrays

val data = Array(10, 20, 30, 40, 50, 60, 70)

data.slice(2, 5)    // Array(30, 40, 50)
data.take(3)        // Array(10, 20, 30)
data.drop(4)        // Array(50, 60, 70)
data.takeWhile(_ < 50)  // Array(10, 20, 30, 40)
data.dropWhile(_ < 50)  // Array(50, 60, 70)

2D Arrays (Matrices)

val matrix = Array(
  Array(1, 2, 3),
  Array(4, 5, 6),
  Array(7, 8, 9)
)

println(matrix(1)(2))   // 6  (row 1, column 2)

// Print the matrix
for row <- matrix do
  println(row.mkString(" "))
// 1 2 3
// 4 5 6
// 7 8 9

       col 0  col 1  col 2
row 0 [  1      2      3  ]
row 1 [  4      5      6  ]
row 2 [  7      8      9  ]

matrix(1)(2) → row 1, col 2 → 6

Array vs List

Feature           Array           List
───────────────   ─────────────   ──────────────────
Mutable?          Yes             No (immutable)
Fixed size?       Yes             No (grows via copy)
Random access     O(1) — fast     O(n) — slow
Prepend           O(n) — slow     O(1) — fast
Java interop      Direct          Needs conversion
Best for          Index access    Functional operations
                  Java APIs       map / filter / fold

Converting Between Array and List

val arr = Array(1, 2, 3, 4, 5)
val lst = arr.toList     // List(1, 2, 3, 4, 5)

val list2 = List(6, 7, 8)
val arr2 = list2.toArray  // Array(6, 7, 8)

Searching in Arrays

val values = Array(15, 42, 7, 98, 33)

values.find(_ > 40)         // Some(42)  — first match
values.exists(_ > 90)       // true
values.forall(_ > 0)        // true
values.indexOf(98)          // 3
values.indexWhere(_ > 40)   // 1  — index of first element > 40
values.filter(_ % 2 == 0)   // Array(42, 98)

Filling and Copying

// Array.fill — all same value
val tenZeros = Array.fill(10)(0)
val fiveHello = Array.fill(5)("hello")

// Array.copyOf equivalents
val original = Array(1, 2, 3, 4, 5)
val copy = original.clone()
copy(0) = 99
println(original(0))  // 1  (original unchanged)
println(copy(0))      // 99

// java.util.Arrays.copyOf also works for Java interop

Practical: Student Scores

val marks = Array(82, 91, 67, 78, 95, 88, 55, 73)

val avg = marks.sum.toDouble / marks.length
val passing = marks.count(_ >= 60)
val highest = marks.max
val lowest = marks.min

println(f"Average:  ${avg}%.1f")
println(s"Passing:  $passing / ${marks.length}")
println(s"Highest:  $highest")
println(s"Lowest:   $lowest")

// Grade distribution
val distribution = marks.groupBy {
  case m if m >= 90 => "A"
  case m if m >= 80 => "B"
  case m if m >= 70 => "C"
  case m if m >= 60 => "D"
  case _            => "F"
}
distribution.toList.sortBy(_._1).foreach { (grade, students) =>
  println(s"$grade: ${students.length} student(s)")
}