Scala, a programming language that combines object-oriented and functional programming paradigms, provides a variety of mutable data structures. Mutable collections such as ArrayBuffer and HashMap facilitate in-place modifications, making them well-suited for situations demanding high-performance, mutable structures. They present a conventional alternative, providing a mutable counterpart to their immutable equivalents.
All the mutable scala collections will be under this package – scala.collection.mutable.
Let’s explore some mutable data structures.
1. Mutable List (ListBuffer):
scala.collection.mutable.ListBuffer is a mutable list implementation in Scala. Unlike immutable lists, elements in a ListBuffer can be added or removed.
Example:
import scala.collection.mutable.ListBuffer
val mutableList = ListBuffer(1, 2, 3)
mutableList += 4 // Appending an element
mutableList -= 2 // Removing an element
Mutable lists, implemented as ListBuffer, are beneficial when frequent modifications to the list are required. They offer efficient append and removal operations.
Common Operations on Mutable Lists (ListBuffer):
Appending and Removing Elements:
mutableList += 5 // Append
mutableList -= 3 // Remove
Inserting Elements:
mutableList.insert(2, 10) // Insert 10 at index 2
Updating Elements:
mutableList(1) = 22 // Update element at index 1
Converting to Immutable List:
val immutableList = mutableList.toList // Convert to immutable list
Iterating Through Elements:
for (element <- mutableList) {
// Process each element
}
Mutable lists can be convenient in scenarios where the structure of the list needs to be altered frequently. In functional programming, immutable lists are generally preferred for their safety and predictability. Consider using mutable lists when performance requirements or specific use cases warrant their use.
2. Mutable Set:
scala.collection.mutable.Set is a mutable set implementation in Scala. It allows elements to be added or removed, providing flexibility for dynamic modifications.
Example:
import scala.collection.mutable.Set
val mutableSet = Set(1, 2, 3)
mutableSet += 4 // Adding an element
mutableSet -= 2 // Removing an element
Mutable sets offer flexibility when dynamic modifications to the set are necessary.
Common Operations on Mutable Sets:
Adding and Removing Elements:
mutableSet += 5 // Add element
mutableSet -= 3 // Remove element
Checking Membership:
val containsTwo = mutableSet.contains(2) // true
Union, Intersection, and Difference:
val anotherSet = Set(3, 4, 5)
val unionSet = mutableSet ++ anotherSet // Union
val intersectionSet = mutableSet.intersect(anotherSet) // Intersection
val differenceSet = mutableSet.diff(anotherSet) // Difference
Converting to Immutable Set:
val immutableSet = mutableSet.toSet // Convert to immutable set
Iterating Through Elements:
for (element <- mutableSet) {
// Process each element
}
Mutable sets can be useful in scenarios where the set’s structure needs frequent modifications. In functional programming, immutable sets are generally preferred for their safety and predictability. The choice between mutable and immutable sets depends on specific use cases and performance considerations.
3. Mutable Map:
scala.collection.mutable.Map is a mutable map implementation in Scala. It allows for adding, updating, and removing key-value pairs, providing flexibility for dynamic modifications.
Example:
import scala.collection.mutable.Map
val mutableMap = Map(“one” -> 1, “two” -> 2, “three” -> 3)
mutableMap += (“four” -> 4) // Adding an entry
mutableMap -= “two” // Removing an entry
mutableMap(“three”) = 33 // Updating a value
Mutable maps offer flexibility when dynamic modifications to the key-value pairs are necessary.
Common Operations on Mutable Maps:
Adding and Removing Entries:
mutableMap += (“five” -> 5) // Add entry
mutableMap -= “three” // Remove entry
Updating Values:
mutableMap(“two”) = 22 // Update value
Checking Key Existence:
val containsTwoKey = mutableMap.contains(“two”) // true
Merging Maps:
val anotherMap = Map(“three” -> 33, “four” -> 4)
mutableMap ++= anotherMap // Merge maps
Converting to Immutable Map:
val immutableMap = mutableMap.toMap // Convert to immutable map
Iterating Through Entries:
for ((key, value) <- mutableMap) {
// Process each key-value pair
}
Mutable maps can be useful in scenarios where the map’s structure needs frequent modifications. In functional programming, immutable maps are generally preferred for their safety and predictability. The choice between mutable and immutable maps depends on specific use cases and performance considerations.
4. Mutable Buffer:
scala.collection.mutable.Buffer is a trait in Scala that represents a mutable, indexed sequence. It extends the scala.collection.mutable.Seq trait, providing a set of methods for adding, updating, and removing elements at specific indices.
Example:
import scala.collection.mutable.Buffer
val mutableBuffer: Buffer[Int] = Buffer(1, 2, 3)
mutableBuffer += 4 // Appending an element
mutableBuffer(1) = 22 // Updating an element
mutableBuffer.remove(2) // Removing an element
Common Operations on Mutable Buffer:
Appending Elements:
mutableBuffer += 5 // Append an element
Updating Elements:
mutableBuffer(1) = 22 // Update element at index 1
Removing Elements:
mutableBuffer.remove(2) // Remove element at index 2
Iterating Through Elements:
for (element <- mutableBuffer) {
// Process each element
}
Mutable buffers, represented by scala.collection.mutable.Buffer, provide a flexible and efficient way to manage dynamic modifications to a sequence. They are particularly useful when frequent changes to the content and structure of the collection are required.
Mutable Collections (from scala.collection.mutable package):
Scala provides various other mutable collections like ArrayBuffer, HashMap, Queue, LinkedList, etc.
References:
Here are the Spark documents delving further into the creation of mutable data structures in Scala.
Official Spark Documentation:
https://docs.scala-lang.org/overviews/collections/overview.html
https://www.scala-lang.org/api/2.12.9/scala/collection/mutable/Buffer.html
Immutable blog: Scala: Immutable data structure / Blogs / Perficient
In conclusion, Mutable data structures in Scala provide developers with the ability to make dynamic changes to the structure and content of collections. They offer flexibility but require careful management of mutable state to avoid unintended side effects, especially in concurrent or parallel programming.
Source: Read More