scala(十六) Set

val set=Set[Int](1,2,3,4,5)

$ scala
Welcome to Scala 2.12.10 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_172).
Type in expressions for evaluation. Or try :help.

scala> val set=Set[Int](1,2,3,4,5)
set: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

&              exists               min                 tails
&~             filter               minBy               take
+              filterNot            mkString            takeRight
++             find                 nonEmpty            takeWhile
++:            flatMap              par                 to
-              flatten              partition           toArray
--             fold                 product             toBuffer
/:             foldLeft             reduce              toIndexedSeq
:\             foldRight            reduceLeft          toIterable
WithFilter     forall               reduceLeftOption    toIterator
addString      foreach              reduceOption        toList
aggregate      genericBuilder       reduceRight         toMap
andThen        groupBy              reduceRightOption   toSeq
apply          grouped              repr                toSet
canEqual       hasDefiniteSize      sameElements        toStream
collect        hashCode             scan                toString
collectFirst   head                 scanLeft            toTraversable
companion      headOption           scanRight           toVector
compose        init                 seq                 transpose
contains       inits                size                union
copyToArray    intersect            slice               unzip
copyToBuffer   isEmpty              sliding             unzip3
count          isTraversableAgain   span                view
diff           iterator             splitAt             withFilter
drop           last                 stringPrefix        zip
dropRight      lastOption           subsetOf            zipAll
dropWhile      map                  subsets             zipWithIndex
empty          max                  sum                 |
equals         maxBy                tail

val set1=Set[Int](1,2,3,4,5)
val set2=Set[Int](4,5,6,7,8)

val newSet=set1.&(set2)

println(newSet)
Set(5, 4)

val newSet=set1.intersect(set2)

println(newSet)
Set(5, 4)

val newSet=set1.&~(set2)

println(newSet)
Set(1, 2, 3)

val newSet=set1.diff(set2)

println(newSet)
Set(1, 2, 3)

val newSet=set1.+(10)

println(newSet)
Set(5, 10, 1, 2, 3, 4)

val newSet=set1.++(set2)

println(newSet)
Set(5, 1, 6, 2, 7, 3, 8, 4)

val newSet=set1.++:(set2)

println(newSet)
Set(5, 1, 6, 2, 7, 3, 8, 4)

val newSet=set1.-(2)

println(newSet)
Set(5, 1, 3, 4)

val newSet=set1.--(Set[Int](1,2))

println(newSet)
Set(5, 3, 4)

for(e <- set1){
  println(s"e=$e")
}

e=5
e=1
e=2
e=3
e=4

import scala.collection.mutable

val set: mutable.Set[Int] = mutable.Set[Int](1, 2, 3, 4, 5, 6, 7)

scala> set.
&              dropRight            maxBy               sum
&~             dropWhile            min                 tail
+              empty                minBy               tails
++             equals               mkString            take
++:            exists               nonEmpty            takeRight
++=            filter               par                 takeWhile
+=             filterNot            partition           to
-              find                 product             toArray
--             flatMap              reduce              toBuffer
--=            flatten              reduceLeft          toIndexedSeq
-=             fold                 reduceLeftOption    toIterable
/:             foldLeft             reduceOption        toIterator
:\             foldRight            reduceRight         toList
<<             forall               reduceRightOption   toMap
WithFilter     foreach              remove              toSeq
add            genericBuilder       repr                toSet
addString      groupBy              result              toStream
aggregate      grouped              retain              toString
andThen        hasDefiniteSize      sameElements        toTraversable
apply          hashCode             scan                toVector
canEqual       head                 scanLeft            transpose
clear          headOption           scanRight           union
clone          init                 seq                 unzip
collect        inits                size                unzip3
collectFirst   intersect            sizeHint            update
companion      isEmpty              sizeHintBounded     view
compose        isTraversableAgain   slice               withFilter
contains       iterator             sliding             zip
copyToArray    last                 span                zipAll
copyToBuffer   lastOption           splitAt             zipWithIndex
count          map                  stringPrefix        |
diff           mapResult            subsetOf
drop           max                  subsets

val set1: mutable.Set[Int] = mutable.Set[Int](1, 2, 3, 4, 5, 6, 7)
val set2: mutable.Set[Int] = mutable.Set[Int](4,5,6,7,8,9,10)

println(set1.&(set2))
Set(5, 6, 7, 4)

val set1: mutable.Set[Int] = mutable.Set[Int](1, 2, 3, 4, 5, 6, 7)
val set2: mutable.Set[Int] = mutable.Set[Int](4,5,6,7,8,9,10)

println(set1.&~(set2))
Set(1, 2, 3)

println(set2.&~(set1))
Set(9, 10, 8)

val set: mutable.Set[Int] = mutable.Set[Int](1, 2, 3, 4, 5, 6, 7)
val newSet: mutable.Set[Int] = set.+(8)

println(newSet)
Set(1, 5, 2, 6, 3, 7, 4, 8)

val set1: mutable.Set[Int] = mutable.Set[Int](1, 2, 3, 4, 5, 6, 7)
val set2: mutable.Set[Int] = mutable.Set[Int](5,6,7,8,9,10)

val newSet: mutable.Set[Int] = set1.++(set2)

println(newSet)
Set(9, 1, 5, 2, 6, 3, 10, 7, 4, 8) //自动去重

val set1: mutable.Set[Int] = mutable.Set[Int](1, 2, 3, 4, 5, 6, 7)
val set2: mutable.Set[Int] = mutable.Set[Int](5,6,7,8,9,10)

set1.++=(set2)

println(set1)
Set(9, 1, 5, 2, 6, 3, 10, 7, 4, 8)  // 自动去重

val set1: mutable.Set[Int] = mutable.Set[Int](1, 2, 3, 4, 5, 6, 7)
set1.+=(9)

println(set1)
Set(9, 1, 5, 2, 6, 3, 7, 4)

val set1: mutable.Set[Int] = mutable.Set[Int](1, 2, 3, 4, 5, 6, 7)

val newSet: mutable.Set[Int] = set1.-(3)

println(newSet)
Set(1, 5, 2, 6, 7, 4)

val set1: mutable.Set[Int] = mutable.Set[Int](1, 2, 3, 4, 5, 6, 7)
val set2: mutable.Set[Int] = mutable.Set[Int](5,6,7,8,9,10)

val newSet: mutable.Set[Int] = set1.--(set2)

println(newSet)
Set(1, 2, 3, 4)

val set1: mutable.Set[Int] = mutable.Set[Int](1, 2, 3, 4, 5, 6, 7)
val set2: mutable.Set[Int] = mutable.Set[Int](5,6,7,8,9,10)

set1.--=(set2)

println(set1)
Set(1, 2, 3, 4)

val set1: mutable.Set[Int] = mutable.Set[Int](1, 2, 3, 4, 5, 6, 7)

set1.-=(4)

println(set1)
Set(1, 5, 2, 6, 3, 7)