A set is a collection that only contains unique items. In Scala, both mutable and immutable sets are available. The mutable set is those set in which the value of the object is change, but, in the immutable set, the value of the object is not changed itself. The immutable set is defined under Scala.collection.immutable._ package and mutable set are defined under Scala.collection.mutable._ package. Here, we will discuss some important methods of Scala.collection.immutable._ package.
1. def +(elem: A): Set[A] – This method is used to add an element to the set and then returns it.
Example :
// Scala program of +() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 8 , 9 , 1 , 4 , 2 , 7 )
// Applying +() method
val result = s.+( 6 )
// Display output
print(result)
}
} |
Output:
Set(1, 6, 9, 2, 7, 8, 4)
2. def -(elem: A): Set[A] – This method is used to remove the element from the set and then returns it.
Example :
// Scala program of -() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 8 , 9 , 1 , 4 , 2 , 7 )
// Applying -() method
val result = s.-( 1 )
// Display output
print(result)
}
} |
Output:
Set(9, 2, 7, 8, 4)
3. def contains(elem: A): Boolean – This method is return true if the set contains the specified element. Otherwise, it will return false.
Example :
// Scala program of contains() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 8 , 9 , 1 , 4 , 2 , 7 )
// Applying contains() method
val result = s.contains( 1 )
// Display output
print(result)
}
} |
Output:
true
4. def &(that: Set[A]): Set[A] – This method is used to return an intersection of two sets.
Example :
// Scala program of &() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s 1 = Set( 8 , 9 , 1 , 4 , 2 , 7 )
val s 2 = Set( 3 , 4 , 6 , 8 )
// Applying &() method
val result = s 1 .&(s 2 )
// Display output
print(result)
}
} |
Output:
Set(8, 4)
5. def &~(that: Set[A]): Set[A] – This symbol means set difference.
Example :
// Scala program of &~() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s 1 = Set( 8 , 9 , 1 , 4 , 2 , 7 )
val s 2 = Set( 3 , 4 , 6 , 8 )
// Applying &~() method
val result = s 1 .&~(s 2 )
// Display output
print(result)
}
} |
Output:
Set(1, 9, 2, 7)
6. def +(elem1: A, elem2: A, elems: A*): Set[A] – This method is used to add the multiple elements to a Scala set and then returns it.
Example :
// Scala program of +() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 8 , 9 , 1 , 4 , 2 , 7 )
// Applying +() method
val result = s.+( 3 , 4 , 6 )
// Display output
print(result)
}
} |
Output:
Set(1, 6, 9, 2, 7, 3, 8, 4)
7. def ++(elems: A): Set[A] – This method is used for concatenation of a set with another.
Example :
// Scala program of ++() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s 1 = Set( 8 , 9 , 1 , 4 , 2 , 7 )
val s 2 = Set( 3 , 4 , 6 )
// Applying ++() method
val result = s 1 ++ s 2 // Display output
print(result)
}
} |
Output:
Set(1, 6, 9, 2, 7, 3, 8, 4)
8. def -(elem1: A, elem2: A, elems: A*): Set[A] – This method is used to remove each element mentioned from the set.
Example :
// Scala program of -() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 8 , 9 , 1 , 4 , 2 , 7 )
// Applying -() method
val result = s.-( 8 , 1 , 3 )
// Display output
print(result)
}
} |
Output:
Set(9, 2, 7, 4)
9. def addString(b: StringBuilder): StringBuilder – This method is used to add all the elements of the set to the String Builder.
Example :
// Scala program of addString() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 8 , 9 , 1 , 4 , 2 , 7 )
// Applying addString() method
val result = s.addString( new StringBuilder())
// Display output
print(result)
}
} |
Output:
192784
10. def addString(b: StringBuilder, sep: String): StringBuilder – This method is used a separator to the above functionality.
Example :
// Scala program of addString() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 8 , 9 , 1 , 4 , 2 , 7 )
// Applying addString() method
val result = s.addString( new StringBuilder(), "*" )
// Display output
print(result)
}
} |
Output:
1*9*2*7*8*4
11. def apply(elem: A) – This method is used to checks whether the element is part of the set or not. It returns Boolean value True or False.
Example :
// Scala program of apply() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 8 , 9 , 1 , 4 , 2 , 7 )
// Applying apply() method
val result = s.apply( 2 )
// Display output
print(result)
}
} |
Output:
true
12. def drop(n: Int): Set[A]] – This method is used to return all elements except the first n.
Example :
// Scala program of drop() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 2 , 3 , 5 , 7 , 8 )
// Applying drop() method
val result = s.drop( 2 )
// Display output
print(result)
}
} |
Output:
Set(7, 3, 8)
13. def dropRight(n: Int): Set[A] – This method is used to returns all elements except the last n that is just opposite to the above method().
Example :
// Scala program of dropRight() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 1 , 2 , 3 , 5 , 7 , 9 )
// Applying dropRight() method
val result = s.dropRight( 2 )
// Display output
print(result)
}
} |
Output:
Set(5, 1, 9, 2)
14. def equals(that: Any): Boolean – This method is used to compares the set to another sequence.
Example :
// Scala program of equals() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 2 , 3 , 5 , 7 , 8 )
// Applying equals() method
val result = s.equals(Set( 2 , 3 , 5 , 7 , 8 ))
// Display output
print(result)
}
} |
Output:
true
15. def head: A – This method is used to return the first element from the set.
Example :
// Scala program of head() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 1 , 2 , 3 , 5 , 7 , 9 )
// Applying head() method
val result = s.head
// Display output
print(result)
}
} |
Output:
5
16. def init: Set[A] – This method is used to return all elements from the set, except the last.
Example :
// Scala program of init() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 1 , 2 , 3 , 5 , 7 , 9 )
// Applying init() method
val result = s.init
// Display output
print(result)
}
} |
Output:
Set(5, 1, 9, 2, 7)
17. def intersect(that: Set[A]): Set[A] – This method is used to return the intersection of two sets that is it returns the common element from the two sets.
Example :
// Scala program of intersect() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s 1 = Set( 1 , 2 , 3 , 5 , 7 , 9 )
val s 2 = Set( 1 , 2 , 3 , 4 , 9 , 9 )
// Applying intersect() method
val result = s 1 .intersect(s 2 )
// Display output
print(result)
}
} |
Output:
Set(1, 9, 2, 3)
18. def isEmpty: Boolean – This method return true if the given set is empty. Otherwise, it will return False.
Example :
// Scala program of isEmpty() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 2 , 3 , 5 , 7 , 8 )
// Applying isEmpty() method
val result = s.isEmpty
// Display output
print(result)
}
} |
Output:
false
19. def iterator: Iterator[A] – This method help in creating a new iterator over the set.
Example :
// Scala program of iterator() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 2 , 3 , 5 , 7 , 8 )
// Applying iterator() method
val result = s.iterator
// Display output
print(result)
}
} |
Output:
non-empty iterator
20. def last: A – This method helps in returning the last element from a set.
Example :
// Scala program of last() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 1 , 2 , 3 , 5 , 7 , 9 )
// Applying last() method
val result = s.last
// Display output
print(result)
}
} |
Output:
3
21. def max: A – This method is used to return the highest value from the set.
Example :
// Scala program of max() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 2 , 3 , 5 , 7 , 8 )
// Applying max() method
val result = s.max
// Display output
print(result)
}
} |
Output:
8
22. def min: A – This method is used to return the lowest element from the set.
Example :
// Scala program of min() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 1 , 2 , 3 , 5 , 7 , 9 )
// Applying min() method
val result = s.min
// Display output
print(result)
}
} |
Output:
1
23. def mkString: String – This method helps to represents all elements of the set as a String.
Example :
// Scala program of mkString() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 2 , 3 , 5 , 7 , 8 )
// Applying mkString() method
val result = s.mkString
// Display output
print(result)
}
} |
Output:
52738
24. def product: A – This method is used to return the product of all elements in the set.
Example :
// Scala program of product() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 1 , 2 , 3 , 5 , 7 , 9 )
// Applying product() method
val result = s.product
// Display output
print(result)
}
} |
Output:
1890
25. def size: Int – This method is used to return the size of the set.
Example :
// Scala program of size() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 2 , 3 , 5 , 7 , 8 )
// Applying size() method
val result = s.size
// Display output
print(result)
}
} |
Output:
5
26. def sum: A – This method is used to return the sum of all elements of the set.
Example :
// Scala program of sum() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 1 , 2 , 3 , 5 , 7 , 9 )
// Applying sum() method
val result = s.sum
// Display output
print(result)
}
} |
Output:
27
27. def tail: Set[A] – This method is used to return all elements of the set except the first.
Example :
// Scala program of tail() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 2 , 3 , 5 , 7 , 8 )
// Applying tail() method
val result = s.tail
// Display output
print(result)
}
} |
Output:
Set(2, 7, 3, 8)
28. def take(n: Int): Set[A] – This method is used to return the first n elements from the set.
Example :
// Scala program of take() // method // Creating object object GfG
{ // Main method
def main(args : Array[String])
{
// Creating a set
val s = Set( 1 , 2 , 3 , 5 , 7 , 9 )
// Applying take() method
val result = s.take( 3 )
// Display output
print(result)
}
} |
Output:
Set(5, 1, 9)
Here are some more methods which are called on a set.
Method | Description |
---|---|
def &(that: Set[A]): Set[A] | This method helps in returning an intersection of two sets. |
def count(p: (A) => Boolean): Int | This method is used to return the count of elements that satisfy the predicate. |
def diff(that: Set[A]): Set[A] | This method is used to return the set difference(elements existing in one set, but not in another). |
def dropWhile(p: (A) => Boolean): Set[A] | This method is used to drop elements until the first element that doesn’t satisfy the predicate. |
def exists(p: (A) => Boolean): Boolean | This method is used to return true if predicate holds true else returns false. |
def filter(p: (A) => Boolean): Set[A] | This method is used to filter elements. |
def find(p: (A) => Boolean): Option[A] | This method is used to return the first element that satisfies the predicate. |
def forall(p: (A) => Boolean): Boolean | This method is used to return true if all elements of the set satisfy the predicate. Otherwise, false. |
def map[B](f: (A) => B): immutable.Set[B] | This method is used to applies the function to all elements of the set and returns it. |
def splitAt(n: Int): (Set[A], Set[A]) | This method is used to split the set at the given index and returns the two resulting subsets. |
def subsetOf(that: Set[A]): Boolean | This method is used to return true if the set passed as argument is a subset of this set else return false. |
def takeRight(n: Int):Set[A] | This method is used to return the last n elements. |
def toArray: Array[A] | This method is used to return an Array holding elements from the set. |
def toList: List[A] | This method is used to return a List from elements of the set. |
def toSeq: Seq[A] | This method is used to return a sequence from the set. |
def toString(): String | This method represents the elements of the set as a String. |