一、Collection

文件地址：https://www.w3cschool.cn/scaladevelopmentguide

序号	集合及描述
1	Scala List(列表)List的特征是其元素以线性方式存储，集合中可以存放重复对象。
2	Scala Set(集合)Set是最简单的一种集合。集合中的对象不按特定的方式排序，并且没有重复对象。
3	Scala Map(映射)Map 是一种把键对象和值对象映射的集合，它的每一个元素都包含一对键对象和值对象。
4	Scala 元组 元组是不同类型的值的集合
5	Scala Option Option[T] 表示有可能包含值的容器，也可能不包含值。
6	Scala Iterator（迭代器）迭代器不是一个容器，更确切的说是逐一访问容器内元素的方法。

// 定义整型 List
val x = List(1,2,3,4)

// 定义 Set
val x = Set(1,3,5,7)

// 定义 Map
val x = Map("one" -> 1, "two" -> 2, "three" -> 3)

// 创建两个不同类型元素的元组
val x = (10, "tom")

// 定义 Option
val x:Option[Int] = Some(5)

1. List

创建列表

scala> val days = List("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday")
days: List[String] = List(Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday)

创建空列表

val l = Nil
l: scala.collection.immutable.Nil.type = List()

scala> val l = List()
l: List[Nothing] = List()

用字符串创建列表

scala> val l = "Hello" :: "Hi" :: "Hah" :: "WOW" :: "WOOW" :: Nil
l: List[String] = List(Hello, Hi, Hah, WOW, WOOW)

用“:::”叠加创建新列表

scala> val wow = l ::: List("WOOOW", "WOOOOW")
wow: List[String] = List(Hello, Hi, Hah, WOW, WOOW, WOOOW, WOOOOW)

通过索引获取列表值

scala> l(3)
res0: String = WOW

获取值长度为3的元素数目

scala> l.count(s => s.length == 3)
res1: Int = 2

返回去掉l头两个元素的新列表

scala> l.drop(2)
res2: List[String] = List(Hah, WOW, WOOW)
 
scala> l
res3: List[String] = List(Hello, Hi, Hah, WOW, WOOW)

返回去掉l后两个元素的新列表

scala> l.dropRight(2)
res5: List[String] = List(Hello, Hi, Hah)
 
scala> l
res6: List[String] = List(Hello, Hi, Hah, WOW, WOOW)

判断l是否存在某个元素

scala> l.exists(s => s == "Hah")
res7: Boolean = true

滤出长度为3的元素

scala> l.filter(s => s.length == 3)
res8: List[String] = List(Hah, WOW)

判断所有元素是否以“H”打头

scala> l.forall(s => s.startsWith("H"))
res10: Boolean = false

判断所有元素是否以“H”结尾

scala> l.forall(s => s.endsWith("W"))
res11: Boolean = false

打印每个元素

scala> l.foreach(s => print(s + ' '))
Hello Hi Hah WOW WOOW

取出第一个元素

scala> l.head
res17: String = Hello

取出最后一个元素

scala> l.last
res20: String = WOOW

剔除最后一个元素，生成新列表

scala> l.init
res18: List[String] = List(Hello, Hi, Hah, WOW)

剔除第一个元素，生成新列表

scala> l.tail
res49: List[String] = List(Hi, Hah, WOW, WOOW)

判断列表是否为空

scala> l.isEmpty
res19: Boolean = false

获得列表长度

scala> l.length
res21: Int = 5

修改每个元素，再反转每个元素形成新列表

scala> l.map(s => {val s1 = s + " - 01"; s1.reverse})
res29: List[String] = List(10 - olleH, 10 - iH, 10 - haH, 10 - WOW, 10 - WOOW)

生成用逗号隔开的字符串

scala> l.mkString(", ")
res30: String = Hello, Hi, Hah, WOW, WOOW

反序生成新列表

scala> l.reverse
res41: List[String] = List(WOOW, WOW, Hah, Hi, Hello)

按字母递增排序

scala> l.sortWith(_.compareTo(_) < 0)
res48: List[String] = List(Hah, Hello, Hi, WOOW, WOW)

2. Set

Scala Set(集合)是没有重复的对象集合，所有的元素都是唯一的。
Scala 集合分为可变的和不可变的集合。
默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable.Set 包。
默认引用 scala.collection.immutable.Set。

创建Set

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

添加元素

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

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

需要注意的是，加了一些元素之后，对于a是否会变化。主要到scala.collection.immutable
初始化

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

加元素

scala> mutableSet+(4)
res141: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
scala> mutableSet
res142: scala.collection.mutable.Set[Int] = Set(1, 2, 3)
scala> mutableSet.add(4)
res143: Boolean = true
scala> mutableSet
res144: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)

删除元素

scala> mutableSet-(4)
res146: scala.collection.mutable.Set[Int] = Set(1, 2, 3)
scala> mutableSet
res147: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
scala> mutableSet.remove(4)
res148: Boolean = true
scala> mutableSet
res149: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

序号	方法及描述
1	def +(elem: A): Set[A]	为集合添加新元素，x并创建一个新的集合，除非元素已存在
2	def -(elem: A): Set[A]	移除集合中的元素，并创建一个新的集合
3	def contains(elem: A): Boolean	如果元素在集合中存在，返回 true，否则返回 false。
4	def &(that: Set[A]): Set[A]	返回两个集合的交集
5	def &~(that: Set[A]): Set[A]	返回两个集合的差集
6	def +(elem1: A, elem2: A, elems: A*): Set[A]	通过添加传入指定集合的元素创建一个新的不可变集合
7	def ++(elems: A): Set[A]	合并两个集合
8	def -(elem1: A, elem2: A, elems: A*): Set[A]	通过移除传入指定集合的元素创建一个新的不可变集合
9	def addString(b: StringBuilder): StringBuilder	将不可变集合的所有元素添加到字符串缓冲区
10	def addString(b: StringBuilder, sep: String): StringBuilder	将不可变集合的所有元素添加到字符串缓冲区，并使用指定的分隔符
11	def apply(elem: A)	检测集合中是否包含指定元素
12	def count(p: (A) => Boolean): Int	计算满足指定条件的集合元素个数
13	def copyToArray(xs: Array[A], start: Int, len: Int): Unit	复制不可变集合元素到数组
14	def diff(that: Set[A]): Set[A]	比较两个集合的差集
15	def drop(n: Int): Set[A]]	返回丢弃前n个元素新集合
16	def dropRight(n: Int): Set[A]	返回丢弃最后n个元素新集合
17	def dropWhile(p: (A) => Boolean): Set[A]	从左向右丢弃元素，直到条件p不成立
18	def equals(that: Any): Boolean	equals 方法可用于任意序列。用于比较系列是否相等。
19	def exists(p: (A) => Boolean): Boolean	判断不可变集合中指定条件的元素是否存在。
20	def filter(p: (A) => Boolean): Set[A]	输出符合指定条件的所有不可变集合元素。
21	def find(p: (A) => Boolean): Option[A]	查找不可变集合中满足指定条件的第一个元素
22	def forall(p: (A) => Boolean): Boolean	查找不可变集合中满足指定条件的所有元素
23	def foreach(f: (A) => Unit): Unit	将函数应用到不可变集合的所有元素
24	def head: A	获取不可变集合的第一个元素
25	def init: Set[A]	返回所有元素，除了最后一个
26	def intersect(that: Set[A]): Set[A]	计算两个集合的交集
27	def isEmpty: Boolean	判断集合是否为空
28	def iterator: Iterator[A]	创建一个新的迭代器来迭代元素
29	def last: A	返回最后一个元素
30	def map[B](f: (A) => B): immutable.Set[B]	通过给定的方法将所有元素重新计算
31	def max: A	查找最大元素
32	def min: A	查找最小元素
33	def mkString: String	集合所有元素作为字符串显示
34	def mkString(sep: String): String	使用分隔符将集合所有元素作为字符串显示
35	def product: A	返回不可变集合中数字元素的积。
36	def size: Int	返回不可变集合元素的数量
37	def splitAt(n: Int): (Set[A], Set[A])	把不可变集合拆分为两个容器，第一个由前 n 个元素组成，第二个由剩下的元素组成
38	def subsetOf(that: Set[A]): Boolean	如果集合中含有子集返回 true，否则返回false
39	def sum: A	返回不可变集合中所有数字元素之和
40	def tail: Set[A]	返回一个不可变集合中除了第一元素之外的其他元素
41	def take(n: Int): Set[A]	返回前 n 个元素
42	def takeRight(n: Int):Set[A]	返回后 n 个元素
43	def toArray: Array[A]	将集合转换为数组
44	def toBuffer[B >: A]: Buffer[B]	返回缓冲区，包含了不可变集合的所有元素
45	def toList: List[A]	返回 List，包含了不可变集合的所有元素
46	def toMap[T, U]: Map[T, U]	返回 Map，包含了不可变集合的所有元素
47	def toSeq: Seq[A]	返回 Seq，包含了不可变集合的所有元素
48	def toString(): String	返回一个字符串，以对象来表示

3. Map

Map(映射)是一种可迭代的键值对（key/value）结构。
所有的值都可以通过键来获取。
Map 中的键都是唯一的。
Map 也叫哈希表（Hash tables）。
Map 有两种类型，可变与不可变，区别在于可变对象可以修改它，而不可变对象不可以。
默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合，你需要显式的引入 import scala.collection.mutable.Map 类
在 Scala 中 你可以同时使用可变与不可变 Map，不可变的直接使用 Map，可变的使用 mutable.Map。

// 空哈希表，键为字符串，值为整型
var A:Map[Char,Int] = Map()

// Map 键值对演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

示例：
···
object Test {
def main(args: Array[String]) {
val colors = Map("red" -> "#FF0000",
"azure" -> "#F0FFFF",
"peru" -> "#CD853F")

  val nums: Map[Int, Int] = Map()

  println( "colors 中的键为 : " + colors.keys )
  println( "colors 中的值为 : " + colors.values )
  println( "检测 colors 是否为空 : " + colors.isEmpty )
  println( "检测 nums 是否为空 : " + nums.isEmpty )

}
}
···

4. Seq序列

创建Seq:

val s1 = Seq(1,2,3,4,5)
val s2 = Seq(6,7,8,9,10)
// 获取某个下标的值

索引和长度

scala> val s1=Seq(1,2,3)
s1: Seq[Int] = List(1, 2, 3)

scala> s1(1)
res0: Int = 2

scala> print(s1(1))
2
// 是否包括该下标，下标从0开始
scala> s1.isDefinedAt(1)
res2: Boolean = true

// seq长度，结果:res0: Int = 5
s1.length
    
// seq长度比n大则返回+1，比n少则返回-1，=n则返回0
s1.lengthCompare(5)
    
// 返回0--(s1.length-1) 的Range
// 结果: res0: scala.collection.immutable.Range = Range 0 until 5
s1.indices

查询下标

     //查询元素1所在的下标
     //结果 res0: Int = 0
     s1.indexOf(1)
     //查找该元素的最后一个索,res0: Int = 2
     val s3 = Seq(1,2,2,4,5,2,2,4)
     s3.lastIndexOf(2)
     //右边seq在左边seq的开始匹配索引
     //结果:res0: Int = 1
     val s4 = Seq(2,2,4)
     s3.indexOfSlice(s4)
     ////右边seq在左边seq的最后匹配索引
     //结果:res0: Int = 5
     s3.lastIndexOfSlice(s4)
     //查找第一个满足条件的索引
     //结果:res0: Int = 3
     s3.indexWhere(_ > 2)
     //从seq(n)开始，连续满足条件的个数
     //结果:res0: Int = 2
     s3.segmentLength(_ > 2,3)
     //从seq(0)开始，连续满足条件的个数
     //res0: Int = 8
     s3.prefixLength(_ > 0)

添加

    //把n加入到集合在头部
    //结果：res0: Seq[Int] = List(6, 1, 2, 3, 4, 5)
    6 +: s1

    //把n加到集合后面
    //结果:res0: Seq[Int] = List(1, 2, 3, 4, 5, 6)
    s1 :+ 6

    //第一个参数len,第二个参数value,如果集合长度达<len,则将集合扩展到len,并用value填充。否则什么都不做
    //结果:res0: Seq[Int] = List(1, 2, 3, 4, 5, 2, 2)
    s1 padTo (7,2)

更新

    // 从下标为2[index]的元素开始，用集合s2所有元素替换掉1[n]个数。
    // 结果:res0: Seq[Int] = List(1, 2, 6, 7, 8, 9, 10, 4, 5)
    s1.patch(2,s2,1)
    // 更新下标i的值
    // 结果:res0: Seq[Int] = List(1, 2, 10, 4, 5)
    s1.updated(2,10)

排序

     val s3 = Seq(4,2,5,8,3,0)
    //按自然升序排
    //结果:res0: Seq[Int] = List(0, 2, 3, 4, 5, 8)
    s3.sorted
    //按自定义函数排序
    //结果:res0: Seq[Int] = List(8, 5, 4, 3, 2, 0)
    s3.sortWith((x,y) => x > y)
    //从大到小,结果:res0: Seq[Int] = List(8, 5, 4, 3, 2, 0)
    s3.sortBy(x => -x)
    //从小到大，结果:res0: Seq[Int] = List(0, 2, 3, 4, 5, 8)
    s3.sortBy(x => x)

反转

    //把集合反转，结果:res0: Seq[Int] = List(5, 4, 3, 2, 1)
    s1.reverse
    //返回反转后的集合迭代器
    //结果:54321
    val it = s1.reverseIterator
    while (it.hasNext) {
      print(it.next())
    }
    //反转集合，按指定函数进行map
    //结果:res0: Seq[Int] = List(6, 5, 4, 3, 2)
    s1.reverseMap(x => x + 1)

比较

    val s3 = Seq(1,2,3)
    //判断是否以另一个集合开始,元素和顺序一致
    //结果:res0: Boolean = true
    s1.startsWith(s3)

    //判断是否以另一个集合结尾，元素和顺序一致
    //结果:res0: Boolean = true
    val s4 = Seq(3,4,5)
    s1.endsWith(s4)

    //判断集合是否包含某个元素
    //结果:res0: Boolean = true
    s1.contains(2)

    //判断是否包含另一个集合的连续字段
    //结果:res0: Boolean = true
    s1.containsSlice(s3)

    //判断两个集合长度，按下标遍历，满足输入函数的返回true，不满足的返回false
    //结果:res0: Boolean = true
    val s5 = Seq(1,2,3,4,5)
    s1.corresponds(s5)((x,y)=>x == y)

多集合操作

     val s3 = Seq(0,1,2,3,4)
     //获取两个集合的交集
     //结果:res0: Seq[Int] = List(1, 2, 3, 4)
     s1.intersect(s3)
     //获取第一个集合有，第二个集合没有的
     //结果:res0: Seq[Int] = List(5)
     s1.diff(s3)
     //两个集合合并
     //结果：res0: Seq[Int] = List(1, 2, 3, 4, 5, 0, 1, 2, 3, 4)
     s1.union(s3)
     //集合去重
     //结果:res0: Seq[Int] = List(1, 2, 3, 4)
     val s4 = Seq(1,1,2,3,2,3,4)
     s4.distinct

可变集合 添加

// 必须导入mutable包
import scala.collection.mutable

scala> import scala.collection.mutable
import scala.collection.mutable

scala> val buffer = mutable.Buffer(1,2,3,4,5)
buffer: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)

    val buffer = mutable.Buffer(1,2,3,4,5)
    val b2 = mutable.Buffer(7,8)
    //向buffer增加一个元素
    //结果:res0: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6)
    buffer += 6

    //向buffer增加几个元素
    //结果:res0: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 7, 8, 9)
    buffer += (7,8,9)

    //添加集合
    //结果:res0: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 7, 8)
    buffer ++= b2

    //把元素放在集合头部
    //结果:res0: scala.collection.mutable.Buffer[Int] = ArrayBuffer(6, 1, 2, 3, 4, 5)
    6 +=: buffer

    //把集合放buffer头部
    //结果:res0: scala.collection.mutable.Buffer[Int] = ArrayBuffer(7, 8, 1, 2, 3, 4, 5)
    b2 ++=: buffer
    //在下标i，插入元素
    //结果:1210345
    buffer.insert(2,10)
    //从下标开始插入整个数组
    //结果:12789345
    val arr = Array(7,8,9)
    buffer.insertAll(2,arr)

可变集合 删除

     val s3 = Seq(0,1,2,3,4)
     //获取两个集合的交集
     //结果:res0: Seq[Int] = List(1, 2, 3, 4)
     s1.intersect(s3)
     //获取第一个集合有，第二个集合没有的
     //结果:res0: Seq[Int] = List(5)
     s1.diff(s3)
     //两个集合合并
     //结果：res0: Seq[Int] = List(1, 2, 3, 4, 5, 0, 1, 2, 3, 4)
     s1.union(s3)
     //集合去重
     //结果:res0: Seq[Int] = List(1, 2, 3, 4)
     val s4 = Seq(1,1,2,3,2,3,4)
     s4.distinct

Scala的Seq将是Java的List，Scala的List将是Java的LinkedList。

5. range()

scala> (1 to 10).toList
res3: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

6. Tuple元组

元组是不同类型的值的集合

    // 简单Tuple
    val t = ("yxj", 30) // Tuple2
    println(t._1) // 访问Tuple中的数据，从1开始，带上下划线
    println(t._2)
 
    val student = new Tuple3(1, "yxj", 30) // Tuple3
    println(student)
 
    //zip操作
    val names = Array("t", "tt", "ttt")
    val ages = Array(10, 20, 30)
    val nameAges = names.zip(ages)
    println(nameAges) // [Lscala.Tuple2;@13deb50e
    println(nameAges.mkString(",")) // (t,10),(tt,20),(ttt,30)
 
    // 增强for循环
    for ((name, age) <- nameAges) {
      println("name=" + name + ",age=" + age)
    }
 
    val students = Array((1, "yxj", 30), (2, "yxj2", 32), (3, "yxj3", 33))
    for ((id, name, age) <- students) {
      println("id=" + id + ",name=" + name + ",age=" + age)
    }

二、Iterator（迭代器）

Scala Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法。
迭代器 it 的两个基本操作是 next 和 hasNext。
调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。
调用 it.hasNext() 用于检测集合中是否还有元素。
让迭代器 it 逐个返回所有元素最简单的方法是使用 while 循环：

bject Test {
   def main(args: Array[String]) {
      val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
      
      while (it.hasNext){
         println(it.next())
      }
   }
}

三、集合操作符

:: +: :+ ++ ++: :::

这些符号全都是连接的作用，将元素与集合、集合与集合相连接。
::操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于9 :: (5 :: (2 :: Nil))。所以:: +: :::这些操作符都是在前面插入（ ++: 除外）。:+ ++ ++:这些是追加、拼接。

符号	操作	结果	位置解释
::	a :: b	List(List(1, 2, 3), 4, 5, 6)	前插 把a当成一个元素，前插到b集合
+:	a +: b	List(List(1, 2, 3), 4, 5, 6)	前插 同上
:+	a :+ b	List(1, 2, 3, List(4, 5, 6))	后插 把b当成一个元素，后插到a集合
++	a ++ b	List(1, 2, 3, 4, 5, 6)	拼接 a和b集合顺序合并
++:	a ++:b	List(1, 2, 3, 4, 5, 6)	拼接 同上
:::	a::::b	List(1, 2, 3, 4, 5, 6)	拼接 同上

scala> val a =  List(1,2,3)
a: List[Int] = List(1, 2, 3)

scala> val b = List(4,5,6)
b: List[Int] = List(4, 5, 6)

scala> a :: b
res20: List[Any] = List(List(1, 2, 3), 4, 5, 6)