In this Scala Sets tutorial, we will learn about sets, how to define Scala Sets, how to process them, and what methods to call on sets in Scala. We will also learn Declaring a set, Operations on sets in Scala collections, Concatenating Sets, Max and Min in a Scala set, and Finding Values common to two sets in Scala.<\/p>\n
So, let’s start the discussion on Scala Sets.<\/p>\n
A Scala Set is a collection that won\u2019t take duplicates. By default, Scala uses immutable sets. But if you want, you can import the scala.collection.mutable.Set class. To be able to refer to both of these in the same collection, we can refer to the immutable set as Set and the mutable set as mutable.Set. You can also learn\u00a0Scala Array<\/a> from our tutorial, once you are done with Scala sets.<\/p>\n You can either declare an empty set in Scala or one with values.<\/p>\n We must include the type annotation when declaring an empty set, so it can be decided what concrete type to assign to a variable.<\/p>\n We may choose to elide the type annotation. When we do so, Scala will infer that from the type of values inside the set.<\/p>\n Note that this does not rearrange values as {1,3,4} as Python would do.<\/p>\n Scala has the following three operations on a set:<\/p>\n This will return the first element of a Scala set.<\/p>\n This will return all elements of a set except the first.<\/p>\n If the set is empty, this will return a Boolean true; otherwise, false.<\/p>\n There are two ways to concatenate sets. Let\u2019s take another Scala set for this:<\/p>\n We can call the ++() method to either set and pass the other to it.<\/p>\n Read: Scala Operators with Syntax and Examples <\/a><\/strong><\/p>\n We can find the maximum and minimum values in a set.<\/p>\n This returns the maximum value from a set.<\/p>\n This returns the minimum value from a set.<\/p>\n To determine the values common to two certain sets, we can use one of two methods. Let\u2019s take two new sets for this:<\/p>\n We can call &() on one set, and pass another to it.<\/p>\n We can use the intersect() method.<\/p>\n Read: Scala Functions with Syntax and Examples <\/a><\/strong><\/p>\n Playing around with sets in Scala, you can call these methods on them. (Note that they do not modify the set itself)<\/p>\n This adds an element to the set and returns it. (But doesn\u2019t modify the original set)<\/p>\n This removes the element from the set and then returns it. Note that this takes an Int instead of a string for our set of Ints.<\/p>\n If the set contains that element, this returns true; otherwise, false.<\/p>\n This returns an intersection of two sets, as we just saw.<\/p>\n &~ stands for set difference.<\/p>\n This adds multiple elements to a Scala set and returns it.<\/p>\n This concatenates a set with another collection.<\/p>\n This removes, each element mentioned from the set.<\/p>\n This adds all elements of the set to the String Builder.<\/p>\n This uses a separator to the above functionality.<\/p>\n This checks whether the element is part of the set.<\/p>\n Read: Scala DataTypes <\/a><\/strong><\/p>\n This returns the count of elements that satisfy the predicate.<\/p>\n These copies len elements<\/i> from the set to the Array xs<\/i>, starting at position start<\/i>.<\/p>\n This returns the set difference(elements existing in one set, but not in another)<\/p>\n This returns all elements except the first n.<\/p>\n This Scala set returns all elements except the last n.<\/p>\n This drops elements until the first element that doesn\u2019t satisfy the predicate.<\/p>\n This set in Scala compares the set to another sequence.<\/p>\n If the predicate holds true for some elements in the set, this returns true; otherwise, false.<\/p>\n This filters such elements (see the previous method)<\/p>\n This Scala set returns the first element that satisfies the predicate.<\/p>\n This returns true if all elements of the set satisfy the predicate; otherwise, false.<\/p>\n This Scala Set returns the first element from the set.<\/p>\n This returns all elements from the set, except the last.<\/p>\n This returns the intersection of two sets(elements common to both).<\/p>\n This set in Scala returns true if the set is empty; otherwise, false.<\/p>\nDeclaring a Set in Scala<\/h3>\n
a. Declaring an Empty Set<\/h4>\n
scala> var s:Set[Int]=Set()\r\ns: Set[Int] = Set()<\/pre>\n
b. Declaring a Set with Values<\/h4>\n
scala> var s=Set(1,4,4,3)\r\ns: scala.collection.immutable.Set[Int] = Set(1, 4, 3)\r\nscala> var s:Set[Int]=Set(1,4,4,3)\r\ns: Set[Int] = Set(1, 4, 3)<\/pre>\n
Operations on Scala Sets<\/h3>\n
a. head<\/h4>\n
scala> s.head\r\nres0: Int = 1<\/pre>\n
b. tail<\/h4>\n
scala> s.tail\r\nres1: scala.collection.immutable.Set[Int] = Set(4, 3)<\/pre>\n
c. isEmpty<\/h4>\n
scala> s.isEmpty\r\nres2: Boolean = false<\/pre>\n
Concatenating Scala Sets<\/h3>\n
scala> var s1=Set(7,9,8,9)\r\ns1: scala.collection.immutable.Set[Int] = Set(7, 9, 8)<\/pre>\n
a. The ++ Operator<\/h4>\n
scala> s++s1\r\nres3: scala.collection.immutable.Set[Int] = Set(1, 9, 7, 3, 8, 4)\r\nscala> s++s1\r\nres4: scala.collection.immutable.Set[Int] = Set(1, 9, 7, 3, 8, 4)\r\nscala> s1++s\r\nres5: scala.collection.immutable.Set[Int] = Set(1, 9, 7, 3, 8, 4)<\/pre>\n
b. The Set.++() Method<\/h4>\n
scala> s.++(s1)\r\nres6: scala.collection.immutable.Set[Int] = Set(1, 9, 7, 3, 8, 4)\r\nscala> s1.++(s)\r\nres7: scala.collection.immutable.Set[Int] = Set(1, 9, 7, 3, 8, 4)<\/pre>\n
Max and Min in a Set<\/h3>\n
a. max<\/h4>\n
scala> s.max\r\nres8: Int = 4<\/pre>\n
b. min<\/h4>\n
scala> s.min\r\nres9: Int = 1<\/pre>\n
Finding Values Common to Two Sets<\/h3>\n
scala> var a=Set(1,4,3,4,2)\r\na: scala.collection.immutable.Set[Int] = Set(1, 4, 3, 2)\r\nscala> var b=Set(7,9,8,2,8)\r\nb: scala.collection.immutable.Set[Int] = Set(7, 9, 8, 2)<\/pre>\n
a. The Set.&() Method<\/h4>\n
scala> a.&(b)\r\nres10: scala.collection.immutable.Set[Int] = Set(2)<\/pre>\n
b. Set.intersect() Method<\/h4>\n
scala> a.intersect(b)\r\nres11: scala.collection.immutable.Set[Int] = Set(2)\r\nscala> b.intersect(a)\r\nres12: scala.collection.immutable.Set[Int] = Set(2)<\/pre>\n
Methods to Call on a Set<\/h3>\n
a. def +(elem: A): Set[A]<\/h4>\n
scala> a.+(\"6\")\r\nres15: String = Set(1, 4, 3, 2)6<\/pre>\n
b. def -(elem: A): Set[A]<\/h4>\n
scala> a.-(2)\r\nres19: scala.collection.immutable.Set[Int] = Set(1, 4, 3)\r\nscala> a.-(6)\r\nres21: scala.collection.immutable.Set[Int] = Set(1, 4, 3, 2)<\/pre>\n
c. def contains(elem: A): Boolean<\/h4>\n
scala> a.contains(2)\r\nres22: Boolean = true\r\nscala> a.contains(6)\r\nres23: Boolean = false<\/pre>\n
d. def &(that: Set[A]): Set[A]<\/h4>\n
scala> a.&(b)\r\nres24: scala.collection.immutable.Set[Int] = Set(2)<\/pre>\n
e. def &~(that: Set[A]): Set[A]<\/h4>\n
scala> a.&~(b) #All elements that are in a, but not in b\r\nres25: scala.collection.immutable.Set[Int] = Set(1, 4, 3)\r\nscala> b.&~(a) #All elements that are in b, but not in a\r\nres26: scala.collection.immutable.Set[Int] = Set(7, 9, 8)<\/pre>\n
f. def +(elem1: A, elem2: A, elems: A*): Set[A]<\/h4>\n
scala> a.+(0,6,7)\r\nres27: scala.collection.immutable.Set[Int] = Set(0, 1, 6, 2, 7, 3, 4)<\/pre>\n
g. def ++(elems: A): Set[A]<\/h4>\n
scala> a.++(List(7,9,8))\r\nres29: scala.collection.immutable.Set[Int] = Set(1, 9, 2, 7, 3, 8, 4)\r\nscala> a.++(b)\r\nres30: scala.collection.immutable.Set[Int] = Set(1, 9, 2, 7, 3, 8, 4)<\/pre>\n
h. def -(elem1: A, elem2: A, elems: A*): Set[A]<\/h4>\n
scala> a.-(2,3,6)\r\nres31: scala.collection.immutable.Set[Int] = Set(1, 4)<\/pre>\n
i. def addString(b: StringBuilder): StringBuilder<\/h4>\n
scala> a.addString(new StringBuilder())\r\nres32: StringBuilder = 1432<\/pre>\n
j. def addString(b: StringBuilder, sep: String): StringBuilder<\/h4>\n
scala> a.addString(new StringBuilder(),\"*\")\r\nres33: StringBuilder = 1*4*3*2<\/pre>\n
k. def apply(elem: A)<\/h4>\n
scala> a.apply(1)\r\nres34: Boolean = true\r\nscala> a.apply(7)\r\nres35: Boolean = false<\/pre>\n
l. def count(p: (A) => Boolean): Int<\/h4>\n
scala> a.count(x=>{x%2!=0})\r\nres36: Int = 2<\/pre>\nm. def copyToArray(xs: Array[A], start: Int, len: Int): Unit<\/h4>\n
scala> var c=Array(0,0,0,0,0,0,0,0)\r\nc: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0)\r\nscala> a.copyToArray(c,3,2)\r\nscala> c\r\nres39: Array[Int] = Array(0, 0, 0, 1, 4, 0, 0, 0)<\/pre>\n
n. def diff(that: Set[A]): Set[A]<\/h4>\n
scala> a.diff(b)\r\nres40: scala.collection.immutable.Set[Int] = Set(1, 4, 3)\r\nscala> b.diff(a)\r\nres42: scala.collection.immutable.Set[Int] = Set(7, 9, 8)<\/pre>\n
o. def drop(n: Int): Set[A]]<\/h4>\n
scala> a.drop(2)\r\nres45: scala.collection.immutable.Set[Int] = Set(3, 2)<\/pre>\n
p. def dropRight(n: Int): Set[A]<\/h4>\n
scala> a.dropRight(2)\r\nres46: scala.collection.immutable.Set[Int] = Set(1, 4)<\/pre>\n
q. def dropWhile(p: (A) => Boolean): Set[A]<\/h4>\n
scala> a.dropWhile(x=>{x%2!=0})\r\nres48: scala.collection.immutable.Set[Int] = Set(4, 3, 2)<\/pre>\nr. def equals(that: Any): Boolean<\/h4>\n
scala> a.equals(List(1,4,3,2))\r\nres50: Boolean = false<\/pre>\n
s. def exists(p: (A) => Boolean): Boolean<\/h4>\n
scala> a.exists(x=>{x%4==0})\r\nres52: Boolean = true\r\nscala> a.exists(x=>{x%5==0})\r\nres53: Boolean = false<\/pre>\nt. def filter(p: (A) => Boolean): Set[A]<\/h4>\n
scala> a.filter(x=>{x%4==0})\r\nres54: scala.collection.immutable.Set[Int] = Set(4)<\/pre>\nu. def find(p: (A) => Boolean): Option[A]<\/h4>\n
scala> a.find(x=>{x%2==0})\r\nres55: Option[Int] = Some(4)<\/pre>\nv. def forall(p: (A) => Boolean): Boolean<\/h4>\n
scala> a.forall(x=>{x%2==0})\r\nres56: Boolean = false<\/pre>\nw. def head: A<\/h4>\n
scala> a.head\r\nres59: Int = 1<\/pre>\n
x. def init: Set[A]<\/h4>\n
scala> a.init\r\nres62: scala.collection.immutable.Set[Int] = Set(1, 4, 3)<\/pre>\n
y. def intersect(that: Set[A]): Set[A]<\/h4>\n
scala> a.intersect(b)\r\nres64: scala.collection.immutable.Set[Int] = Set(2)\r\nscala> b.intersect(a)\r\nres65: scala.collection.immutable.Set[Int] = Set(2)<\/pre>\n
z. def isEmpty: Boolean<\/h4>\n
scala> a.isEmpty\r\nres66: Boolean = false<\/pre>\n