Sets | Collections In Scala

Introduction to Sets

In Scala, a Set is an unordered collection of unique elements. Sets do not allow duplicate values, which makes them suitable for storing distinct items. They can be thought of as a mathematical set.

Scala provides two main types of sets:

Immutable Sets: These are sets that cannot be modified after they are created.
Mutable Sets: These sets can be modified, allowing additions and removals of elements.

Creating Sets

You can create sets in Scala using the Set companion object. Here are examples of creating both immutable and mutable sets:

Immutable Set

val immutableSet = Set(1, 2, 3, 4, 5)

This creates an immutable set containing the numbers from 1 to 5.

Mutable Set

import scala.collection.mutable.Set

val mutableSet = Set(1, 2, 3)

This creates a mutable set. You need to import the mutable collection first.

Basic Operations on Sets

Sets support various operations. Here are some common operations:

Adding Elements: You can add elements to a mutable set.
Removing Elements: You can remove elements from a mutable set.
Checking Membership: You can check if an element is in a set.

Adding and Removing Elements

mutableSet += 4 // Add 4

mutableSet -= 2 // Remove 2

mutableSet: Set(1, 3, 4)

After adding 4 and removing 2, the mutable set contains 1, 3, and 4.

Membership Check

val containsThree = mutableSet.contains(3)

containsThree: Boolean = true

This checks if 3 is a member of the set, returning true.

Set Operations

Sets also support various mathematical operations:

Union: Combines two sets.
Intersection: Finds common elements between two sets.
Difference: Finds elements in one set that are not in another.

Union Example

val setA = Set(1, 2, 3)

val setB = Set(3, 4, 5)

val unionSet = setA union setB

unionSet: Set(1, 2, 3, 4, 5)

The union of setA and setB results in a set containing all unique elements.

Intersection Example

val intersectionSet = setA intersect setB

intersectionSet: Set(3)

The intersection of setA and setB results in a set containing the common element 3.

Difference Example

val differenceSet = setA diff setB

differenceSet: Set(1, 2)

The difference between setA and setB results in a set containing elements that are in setA but not in setB.

Conclusion

Sets in Scala are a powerful tool for managing collections of unique elements. With both immutable and mutable sets, you can perform a variety of operations efficiently. Understanding sets is essential for effective programming in Scala, especially when dealing with distinct items and mathematical operations.