Scala集合Set类型的元素是无序不重复的。Scala集合分为可变集合和不可变集合两种。默认情况下，Scala集合是不可变的，即使用的是scala.collection.immutable.Set包；如果需要使用可变集合，需要导入scala.collection.mutable.Set 包。
1.集合定义
不可变集合示例：
object Test1 {
def main(args:Array[String]){
val set = Set(1,2,3);
println(set.getClass.getName);
println(set.exists(_%2 == 0));
println(set.drop(1));
}
}
编译并执行以上代码，输出结果如下：
E:\Scala>scalac Test1.scala
E:\Scala>scala Test1
scala.collection.immutable.Set$Set3
true
Set(2, 3)
可变集合示例：
import scala.collection.mutable.Set;
object Test2{
def main(args:Array[String]){
val mutableSet = Set(1,2,3);
println(mutableSet.getClass.getName);
mutableSet.add(4);
mutableSet.remove(1);
mutableSet += 5;
mutableSet -= 2;
println(mutableSet);
val set = mutableSet.toSet;
println(set.getClass.getName);
}
}
编译并执行以上代码，输出结果如下：
E:\Scala>scalac Test2.scala
E:\Scala>scala Test2
scala.collection.mutable.HashSet
Set(5, 3, 4)
scala.collection.immutable.Set$Set3
注意：虽然可变集合和不可变集合都有添加或删除元素的操作，但是这是不一样的，修改不可变集合是产生了一个新的集合，原来的集合并没有被修改；修改可变集合就是修改的集合本身，没有产生新的集合。
2.集合基本操作
Scala集合有以下三个基本操作：
- head返回集合第一个元素
- tail返回一个除第一个元素外的集合
- isEmpty在集合为空时返回true
对于Scala集合的任何操作都可以使用这三个基本操作来表示。示例如下：
object Test3 {
def main(args:Array[String]){
val set = Set(1,2,3);
val empty:Set[Int] = Set();
println("set.head = "+set.head);
println("set.tail = "+set.tail);
println("set.isEmpty = "+set.isEmpty);
println("empty.isEmpty = "+empty.isEmpty);
}
}
编译并执行以上代码，输出结果如下：
E:\Scala>scalac Test3.scala
E:\Scala>scala Test3
set.head = 1
set.tail = Set(2, 3)
set.isEmpty = false
empty.isEmpty = true
3.集合连接操作
可以使用++运算符或者Set.++()方法来连接两个集合。如果被连接的集合有重复元素，则连接结果中去除重复元素。示例如下：
object Test4 {
def main(args:Array[String]){
val set1 = Set(1,2,3);
val set2 = Set(4,5,6);
val res1 = set1++set2;
val res2 = set1.++(set2);
println("set1++set2 = "+res1);
println("set1.++(set2) = "+res2);
}
}
编译并执行以上代码，输出结果如下：
E:\Scala>scalac Test4.scala
E:\Scala>scala Test4
set1++set2 = Set(5, 1, 6, 2, 3, 4)
set1.++(set2) = Set(5, 1, 6, 2, 3, 4)
4.集合最值操作
使用Set.min方法来查找集合中最小值；使用Set.max方法来查找集合中最大值；示例如下：
object Test5 {
def main(args:Array[String]){
val set = Set(1,8,2,10,3,-3);
println("set = "+set);
println("set.min = "+set.min);
println("set.max = "+set.max);
}
}
编译并执行以上代码，输出结果如下：
E:\Scala>scalac Test5.scala
E:\Scala>scala Test5
set = Set(10, -3, 1, 2, 3, 8)
set.min = -3
set.max = 10
5.集合交集操作
可以使用Set.&方法或者Set.intersect方法来查看两个集合的交集的元素。示例如下：
object Test6 {
def main(args:Array[String]){
val set1 = Set(1,2,3,4,5);
val set2 = Set(2,3,5,8);
println("set1 = "+set1);
println("set2 = "+set2);
println("set1.&(set2) = "+set1.&(set2));
println("set1.intersect(set2) = "+set1.intersect(set2));
}
}
编译并执行以上代码，输出结果如下：
E:\Scala>scalac Test6.scala
E:\Scala>scala Test6
set1 = Set(5, 1, 2, 3, 4)
set2 = Set(2, 3, 5, 8)
set1.&(set2) = Set(5, 2, 3)
set1.intersect(set2) = Set(5, 2, 3)
6.集合常用的方法
下面列出了Scala中集合的常用方法：
def +(elem: A): Set[A]
为集合添加新元素，x并创建一个新的集合，除非元素已存在
def -(elem: A): Set[A]
移除集合中的元素，并创建一个新的集合
def contains(elem: A): Boolean
如果元素在集合中存在，返回 true，否则返回 false。
def &(that: Set[A]): Set[A]
返回两个集合的交集
def &~(that: Set[A]): Set[A]
返回两个集合的差集
def +(elem1: A, elem2: A, elems: A*): Set[A]
通过添加传入指定集合的元素创建一个新的不可变集合
def ++(elems: A): Set[A]
合并两个集合
def -(elem1: A, elem2: A, elems: A*): Set[A]
通过移除传入指定集合的元素创建一个新的不可变集合
def addString(b: StringBuilder): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区
def addString(b: StringBuilder, sep: String): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区，并使用指定的分隔符
def apply(elem: A)
检测集合中是否包含指定元素
def count(p: (A) => Boolean): Int
计算满足指定条件的集合元素个数
def copyToArray(xs: Array[A], start: Int, len: Int): Unit
复制不可变集合元素到数组
def diff(that: Set[A]): Set[A]
比较两个集合的差集
def drop(n: Int): Set[A]]
返回丢弃前n个元素新集合
def dropRight(n: Int): Set[A]
返回丢弃最后n个元素新集合
def dropWhile(p: (A) => Boolean): Set[A]
从左向右丢弃元素，直到条件p不成立
def equals(that: Any): Boolean
equals 方法可用于任意序列。用于比较系列是否相等。
def exists(p: (A) => Boolean): Boolean
判断不可变集合中指定条件的元素是否存在。
def filter(p: (A) => Boolean): Set[A]
输出符合指定条件的所有不可变集合元素。
def find(p: (A) => Boolean): Option[A]
查找不可变集合中满足指定条件的第一个元素
def forall(p: (A) => Boolean): Boolean
查找不可变集合中满足指定条件的所有元素
def foreach(f: (A) => Unit): Unit
将函数应用到不可变集合的所有元素
def head: A
获取不可变集合的第一个元素
def init: Set[A]
返回所有元素，除了最后一个
def intersect(that: Set[A]): Set[A]
计算两个集合的交集
def isEmpty: Boolean
判断集合是否为空
def iterator: Iterator[A]
创建一个新的迭代器来迭代元素
def last: A
返回最后一个元素
def map[B](f: (A) => B): immutable.Set[B]
通过给定的方法将所有元素重新计算
def max: A
查找最大元素
def min: A
查找最小元素
def mkString: String
集合所有元素作为字符串显示
def mkString(sep: String): String
使用分隔符将集合所有元素作为字符串显示
def product: A
返回不可变集合中数字元素的积。
def size: Int
返回不可变集合元素的数量
def splitAt(n: Int): (Set[A], Set[A])
把不可变集合拆分为两个容器，第一个由前 n 个元素组成，第二个由剩下的元素组成
def subsetOf(that: Set[A]): Boolean
如果集合中含有子集返回 true，否则返回false
def sum: A
返回不可变集合中所有数字元素之和
def tail: Set[A]
返回一个不可变集合中除了第一元素之外的其他元素
def take(n: Int): Set[A]
返回前 n 个元素
def takeRight(n: Int):Set[A]
返回后 n 个元素
def toArray: Array[A]
将集合转换为数组
def toBuffer[B >: A]: Buffer[B]
返回缓冲区，包含了不可变集合的所有元素
def toList: List[A]
返回 List，包含了不可变集合的所有元素
def toMap[T, U]: Map[T, U]
返回 Map，包含了不可变集合的所有元素
def toSeq: Seq[A]
返回 Seq，包含了不可变集合的所有元素
def toString(): String
返回一个字符串，以对象来表示
