1. Introduction

Sets in Scala are collections that store unique elements, meaning no duplicates are allowed. They are particularly useful when you need to ensure that each element appears only once. Scala provides both mutable and immutable versions of Sets. This post will explore and demonstrate various methods provided by Scala's immutable Set.

Scala Set Methods:

Scala Set provides a number of methods to perform operations such as adding, removing, and checking for elements. Some of the commonly used Set methods include:

- +: Adds an element to the Set.

- -: Removes an element from the Set.

- ++: Adds multiple elements (union of Sets).

- --: Removes multiple elements.

- &: Intersection of two Sets.

- contains: Checks if an element is in the Set.

- isEmpty: Checks if the Set is empty.

- size: Returns the number of elements in the Set.

- foreach: Applies a function to all elements in the Set.

- subsetOf: Checks if the Set is a subset of another Set.

- head, tail: Returns the first element and the Set without the first element, respectively.

2. Program Steps

1. Create example Sets to demonstrate each method.

2. Apply various Set methods and print the results.

3. Execute the code to observe the behavior of each method.

3. Code Program

object SetMethodsDemo extends App {
  val set1: Set[Int] = Set(1, 2, 3, 4)
  val set2: Set[Int] = Set(3, 4, 5, 6)

  // Adding an element
  val setWithAddedElement: Set[Int] = set1 + 5
  println(s"Set with added element: $setWithAddedElement")

  // Removing an element
  val setWithRemovedElement: Set[Int] = set1 - 3
  println(s"Set with removed element: $setWithRemovedElement")

  // Union of Sets
  val unionSet: Set[Int] = set1 ++ set2
  println(s"Union of sets: $unionSet")

  // Intersection of Sets
  val intersectionSet: Set[Int] = set1 & set2
  println(s"Intersection of sets: $intersectionSet")

  // Difference of Sets
  val differenceSet: Set[Int] = set1 -- set2
  println(s"Difference of sets: $differenceSet")

  // Checking for an element
  println(s"Does set1 contain 3? ${set1.contains(3)}")

  // Checking if Set is empty
  println(s"Is set1 empty? ${set1.isEmpty}")

  // Getting the size of the Set
  println(s"Size of set1: ${set1.size}")

  // Iterating over a Set
  print("Elements in set1: ")
  set1.foreach(e => print(e + " "))

  // Checking if a set is a subset of another
  println(s"\nIs set1 a subset of set2? ${set1.subsetOf(set2)}")

  // Getting the head and tail of the Set
  println(s"Head of set1: ${set1.head}")
  println(s"Tail of set1: ${set1.tail}")
}

Output:

Set with added element: Set(1, 2, 3, 4, 5)
Set with removed element: Set(1, 2, 4)
Union of sets: Set(1, 2, 3, 4, 5, 6)
Intersection of sets: Set(3, 4)
Difference of sets: Set(1, 2)
Does set1 contain 3? true
Is set1 empty? false
Size of set1: 4
Elements in set1: 1 2 3 4
Is set1 a subset of set2? false
Head of set1: 1
Tail of set1: Set(2, 3, 4)

Explanation:

1. set1 + 5 demonstrates adding an element to a Set, resulting in a new Set including 5.

2. set1 - 3 shows removing an element, 3, from the Set.

3. set1 ++ set2 creates a union of set1 and set2, combining all elements from both.

4. set1 & set2 finds the intersection, which includes only the common elements.

5. set1 -- set2 calculates the difference, including elements in set1 but not in set2.

6. set1.contains(3) checks if 3 is an element of set1.

7. set1.isEmpty and set1.size provide information about the Set's emptiness and size.

8. set1.foreach iterates over each element in set1, printing them.

9. set1.subsetOf(set2) checks if all elements of set1 are in set2.

10. set1.head and set1.tail give the first element and the Set excluding the first element, respectively.