scala学习--集合Set的常用方法及示例

Scala Set(集合)

没有重复的对象集合，所有的元素都是唯一的
Scala 集合分为可变的和不可变的集合。

默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，
需要引用 scala.collection.mutable.Set 包

import scala.collection.mutable.Set // 可以在任何地方引入 可变集合

val mutableSet = Set(1,2,3)
println(mutableSet.getClass.getName) // scala.collection.mutable.HashSet

mutableSet.add(4)
mutableSet.remove(1)
mutableSet += 5
mutableSet -= 2

println(mutableSet) // Set(5, 3, 4)

val another = mutableSet.toSet
println(another.getClass.getName) // scala.collection.immutable.Set

注意： 虽然可变Set和不可变Set都有添加或删除元素的操作，但是有一个非常大的差别。
对不可变Set进行操作，会产生一个新的set，原来的set并没有改变，这与List一样。
而对可变Set进行操作，改变的是该Set本身，与ListBuffer类似。

声明方式：

scala> var a:Set[Int]=Set(1,2,3)
a: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

scala> var a:Set[Int]=Set[Int](1,2,3)
a: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

scala> var a=Set[Int](1,2,3)
a: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

scala> var a=Set(1,2,3)
a: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

+ 为集合添加新元素，x并创建一个新的集合，除非元素已存在

def +(elem: A): Set[A]

scala> a
res189: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

scala> var b = a+4
b: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)

scala> b
res192: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)

- 移除集合中的元素，并创建一个新的集合

def -(elem: A): Set[A]

scala> a
res194: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> var b = a-1
b: scala.collection.immutable.Set[Int] = Set(2, 3)

scala> b
res195: scala.collection.immutable.Set[Int] = Set(2, 3)

contains 如果元素在集合中存在，返回 true，否则返回 false。

def contains(elem: A): Boolean

scala> a
res196: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.contains(2)
res197: Boolean = true

scala> a.contains(4)
res198: Boolean = false

& 交集

def &/intersect(that: Set[A]): Set[A]

返回两个集合的交集
scala> a&b
res205: scala.collection.immutable.Set[Int] = Set(2, 3)

scala> a
res206: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> b
res207: scala.collection.immutable.Set[Int] = Set(2, 3, 4)

scala> a&b
res208: scala.collection.immutable.Set[Int] = Set(2, 3)

scala> a.intersect(b)
res210: scala.collection.immutable.Set[Int] = Set(2, 3)

差集（-- &~ diff）

def &~(that: Set[A]): Set[A]

返回两个集合的差集
scala> a&~b
res213: scala.collection.immutable.Set[Int] = Set(1)

scala> a--b
res214: scala.collection.immutable.Set[Int] = Set(1)

scala> a.diff(b)
res215: scala.collection.immutable.Set[Int] = Set(1)

并集（++ | union）

def ++(elems: A): Set[A]

合并两个集合
scala> a
res216: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> b
res217: scala.collection.immutable.Set[Int] = Set(2, 3, 4)

scala> a++b
res218: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)

scala> a|b
res219: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)

scala> a.union(b)
res220: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)

+/-通过添加/移除传入指定集合的元素创建一个新的不可变集合

def +/-(elem1: A, elem2: A, elems: A*): Set[A]

scala> a
res222: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a+(5,6)
res223: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3)

scala> a-(1)
res224: scala.collection.immutable.Set[Int] = Set(2, 3)

addString 将不可变集合的所有元素添加到字符串缓冲区

def addString(b: StringBuilder): StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

将不可变集合的所有元素添加到字符串缓冲区，并使用指定的分隔符
scala> a
res242: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> var b=new StringBuilder()
b: StringBuilder =

scala> a.addString(b)
res243: StringBuilder = 123

scala> b
res244: StringBuilder = 123

apply 检测集合中是否包含指定元素

def apply(elem: A)

scala> a
res245: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.apply(1)
res246: Boolean = true

count 计算满足指定条件的集合元素个数

def count(p: (A) => Boolean): Int

scala> a
res250: scala.collection.immutable.Set[String] = Set(a, aa, aaa, bbb)

scala> a.count(x=>x.size==3)
res251: Int = 2

copyToArray 复制不可变集合元素到数组

def copyToArray(xs: Array[A], start: Int, len: Int): Unit

scala> a
res256: scala.collection.immutable.Set[String] = Set(a, aa, aaa, bbb)

scala> b
res257: Array[String] = Array(null, null, null, null)

scala> a.copyToArray(b)

scala> b
res259: Array[String] = Array(a, aa, aaa, bbb)

drop/dropRight 返回丢弃前/最后n个元素新集合

def drop(n: Int): Set[A]]
def dropRight(n: Int): Set[A]

scala> a
res260: scala.collection.immutable.Set[String] = Set(a, aa, aaa, bbb)

scala> a.drop(1)
res261: scala.collection.immutable.Set[String] = Set(aa, aaa, bbb)

scala> a.dropRight(1)
res262: scala.collection.immutable.Set[String] = Set(a, aa, aaa)

dropWhile 从左向右丢弃元素，直到条件p不成立

def dropWhile(p: (A) => Boolean): Set[A]

scala> a
res0: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)

scala> a.dropWhile(x=>x<3)
res1: scala.collection.immutable.Set[Int] = Set(3, 4)

equals 用于任意序列。用于比较系列是否相等

def equals(that: Any): Boolean

scala> a
res265: scala.collection.immutable.Set[String] = Set(a, aa, aaa, bbb)

scala> b
res266: scala.collection.immutable.Set[String] = Set(aa, a, aaa, bbb)

scala> a.equals(b)
res267: Boolean = true

exists 判断不可变集合中指定条件的元素是否存在

def exists(p: (A) => Boolean): Boolean

scala> a
res270: scala.collection.immutable.Set[String] = Set(a, aa, aaa, bbb)

scala> a.exists(x=>x.size==2)
res271: Boolean = true

filter 输出符合指定条件的所有不可变集合元素

def filter(p: (A) => Boolean): Set[A]

scala> a
res273: scala.collection.immutable.Set[String] = Set(a, aa, aaa, bbb)

scala> a.filter(x=>x.size==3)
res274: scala.collection.immutable.Set[String] = Set(aaa, bbb)

find 查找不可变集合中满足指定条件的第一个元素scala> a

def find(p: (A) => Boolean): Option[A]

res279: scala.collection.immutable.Set[String] = Set(a, aa, aaa, bbb)

scala> a.find(x=>x.size==1)
res280: Option[String] = Some(a)

forall 查找指定条件是否适用于此集合的所有元素

def forall(p: (A) => Boolean): Boolean

scala> a
res281: scala.collection.immutable.Set[String] = Set(a, aa, aaa, bbb)

scala> a.forall(x=>x.size>0)
res282: Boolean = true

foreach 将函数应用到不可变集合的所有元素

def foreach(f: (A) => Unit): Unit

scala> a
res293: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.foreach((x:Int)=>print(x+" "))
1 2 3

head 获取不可变集合的第一个元素

def head: A

scala> a
res295: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.head
res296: Int = 1

intersect 返回所有元素，除了最后一个

def init: Set[A]

scala> a
res297: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.init
res298: scala.collection.immutable.Set[Int] = Set(1, 2)

intersect 计算两个集合的交集

def intersect(that: Set[A]): Set[A]

scala> a
res305: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> b
res306: scala.collection.immutable.Set[Int] = Set(2, 3, 4)

scala> a.intersect(b)
res307: scala.collection.immutable.Set[Int] = Set(2, 3)

isEmpty 判断集合是否为空

def isEmpty: Boolean

scala> a
res305: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.isEmpty
res308: Boolean = false

iterator 创建一个新的迭代器来迭代元素

def iterator: Iterator[A]

scala> var b=a.iterator
b: Iterator[Int] = non-empty iterator

scala> println(b.next())
1

scala> println(b.next())
2

scala> println(b.next())
3

last 返回最后一个元素

def last: A

scala> a
res313: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.last
res314: Int = 3

map 通过给定的方法将所有元素重新计算

def map[B](f: (A) => B): immutable.Set[B]

scala> a
res315: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.map(x=>x+2)
res316: scala.collection.immutable.Set[Int] = Set(3, 4, 5)
scala> a.map(_+2)
res318: scala.collection.immutable.Set[Int] = Set(3, 4, 5)

max/min 查找最大/小元素

def max/min: A

scala> a
res320: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.max
res321: Int = 3

scala> a.min
res322: Int = 1

mkString 集合所有元素作为字符串显示

def mkString: String

scala> a
res323: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.mkString
res324: String = 123

mkString 使用分隔符将集合所有元素作为字符串显示

def mkString(sep: String): String

scala> a.mkString(" ")
res325: String = 1 2 3

product 返回不可变集合中数字元素的积。

def product: A

scala> a
res326: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.product
res327: Int = 6

size 返回不可变集合元素的数量

def size: Int

scala> a
res329: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.size
res330: Int = 3

splitAt 把不可变集合拆分为两个容器，第一个由前 n 个元素组成，第二个由剩下的元素组成

def splitAt(n: Int): (Set[A], Set[A])

scala> a
res331: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.splitAt(2)
res332: (scala.collection.immutable.Set[Int], scala.collection.immutable.Set[Int]) = (Set(1, 2),Set(3))

subsetOf 如果集合中含有子集返回 true，否则返回false

def subsetOf(that: Set[A]): Boolean

scala> a
res335: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> var b = Set(1,2)
b: scala.collection.immutable.Set[Int] = Set(1, 2)

scala> a.subsetOf(b)
res337: Boolean = false

scala> b.subsetOf(a)
res338: Boolean = true

sum 返回不可变集合中所有数字元素之和

def sum: A 

scala> a
res339: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.sum
res340: Int = 6

tail 返回一个不可变集合中除了第一元素之外的其他元素

def tail: Set[A]

scala> a
res342: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.tail
res343: scala.collection.immutable.Set[Int] = Set(2, 3)

take /takeRight 返回前 n 个元素 返回后 n 个元素

def take(n: Int): Set[A]
def takeRight(n: Int):Set[A]

scala> a
res344: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.take(2)
res345: scala.collection.immutable.Set[Int] = Set(1, 2)

scala> a.takeRight(2)
res346: scala.collection.immutable.Set[Int] = Set(2, 3)

toArray 将集合转换为数组

def toArray: Array[A]

scala> a
res349: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.toArray
res350: Array[Int] = Array(1, 2, 3)

toBuffer 返回缓冲区，包含了不可变集合的所有元素

def toBuffer[B >: A]: Buffer[B]

scala> a
res352: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.toBuffer[Int]
res353: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3)

toList 返回 List，包含了不可变集合的所有元素

def toList: List[A]

scala> a
res354: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.toList
res355: List[Int] = List(1, 2, 3)

toMap 返回 Map，包含了不可变集合的所有元素

def toMap[T, U]: Map[T, U]

scala> a
res356: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.map(x=>(x+x,x))
res357: scala.collection.immutable.Set[(Int, Int)] = Set((2,1), (4,2), (6,3))

scala> a.map(x=>(x+x,x)).toMap
res358: scala.collection.immutable.Map[Int,Int] = Map(2 -> 1, 4 -> 2, 6 -> 3)

toString 返回一个字符串，以对象来表示

def toString(): String

scala> a
res360: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> a.toString
res361: String = Set(1, 2, 3)