scala的集合系统的区分了可变（ mutable ）和不可变（immutable ）集合。
mkString(seq:String) ：方法是将原字符串使用特定的字符串seq分割。
mkString(statrt:String,seq:String,end:String) ：方法是将原字符串使用特定的字符串seq分割的同时，在原字符串之前添加字符串start，在其后添加字符串end。
var str0 = "scala"
println(str0.mkString(",")) //separate string with comma
println(str0.mkString("begin", ",", "end"))
val a = List(1,2,3,4)
val b = new StringBuilder()
println(a.mkString("List(" , "- " , ")"))
输出格式：
s,c,a,l,a
begins,c,a,l,aend
List(1- 2- 3- 4)
备注： 集合中的大部分都存在（指名字相同的类分别存在）三个包中：collection、mutable、immutable，只有trait Buffer只存在mutable集合中
不可变数组Array
与Java中不同的是，Scala中没有数组这一种类型。在Scala中，Array类的功能就与数组类似。与所有数组一样，Array的长度不可变，里面的数据可以按索引位置访问
备注 ： Array是在scala包下，而不是在scala.collection包下
//第一种构造：指定泛型，指定长度
val array1 = new Array[Int](5)
array1(1) = 1 // 实际上调用的是实例对象update方法，等价arr1.update(1,1)
println(array1(1))
//第二种构造：初始化元素，可以是任意类型，实质是隐式调用apply方法
val array2 = Array(0, 1, 2, 3, 4)
println(array2(3))
//增加元素（由于创建的是不可变数组，增加元素，其实是产生新的数组）
val ints: Array[Int] = array1 :+ 5 //元素加在数组最后面 巧记：:写在集合的那一侧
val newArr3 = 15 +: array2 //元素加在数组最前面
val newArr4 = 19 +: 29 +: newArr3 :+ 26 :+ 73 // 19,29,15,0,1,2,3,4,26,73
println(newArr4.mkString(","))
// 数组的遍历
// 第一种方式
for (i <- 0 until array1.length) {
println(array1(i))
}
// 第二种方式
for (i <- array1.indices) println(array1(i))
// 第三种方式
for (elem <- array1) println(elem)
// 第四种方式
array1.foreach(println)
// 第五种方式
val iter = array1.iterator
while (iter.hasNext)
println(iter.next())
update 方法
当对带有括号并包括一到若干参数的对象进行赋值时，编译器将使用对象的 update 方法对括号里的参数和等号右边的对象执行调用
object Third {
def main(args: Array[String]): Unit = {
val obj = new SomeClass
val result = (obj(1, "key1") = "Hello")
println(result)
}
}
class SomeClass {
def update(arg1: Int, arg2: String, arg3: String): String = {
println("update method called")
arg1 + "|" + arg2 + "|" + arg3
}
}
执行结果
update method called
1|key1|Hello
在应用 update 时，等号右边的值会作为 update 方法的最后一个参数。 因此，我们可以看到，update方法被默认调用，这个也是scala这门语言的便捷之处，往往通过隐式的方法，实际上调用的确实背后真的方法
可变数组ArrayBuffer
ArrayBuffer混入了mutable下Seq的两个子trait：IndexedSeq、Buffer，与Array一样，元素有先后之分，可以重复，可以随机访问，但是插入的效率不高。
val arr = new mutable.ArrayBuffer[Int]()
arr.append(1) //等价于+=，但可添加多个
// :+不会在arr1 上添加元素，而是新生成一个ArrayBuffer
val newArr1 = arr :+ 2
println(arr == newArr1) //false
val newArr2 = arr += 3 //元素加在数组最后面
println(arr == newArr2) //true
newArr2 += 4
println(arr) //ArrayBuff(1, 3, 4)，因为是引用类型，所以对于可变集合，不建议添加元素后赋值给一个新变量
5 +=: arr //元素5加在数组前面
println(arr) // ArrayBuffer(5, 1, 3, 4)
arr.prepend(6) //等价于+=:，但可添加多个
println(arr) // ArrayBuffer(6, 5, 1, 3, 4)
arr.insert(1, 13, 59) //在指定的位置开始添加
println(arr) // ArrayBuffer(6, 13, 59, 5, 1, 3, 4) 在索引1的位置添加13 59
arr.insertAll(2, newArr1) // newArr1 ArrayBuffer(1, 2)
println(arr) // ArrayBuffer(6, 13, 1, 2, 59, 5, 1, 3, 4)
arr.prependAll(newArr2) // newArr2 = arr 在前面添加
println(arr) // ArrayBuffer(6, 13, 1, 2, 59, 5, 1, 3, 4, 6, 13, 1, 2, 59, 5, 1, 3, 4)
arr.remove(3, 10) // 删除指定的位置开始后10个元素 删除 [2, 59, 5, 1, 3, 4, 6, 13, 1, 2]
println(arr) // ArrayBuffer(6, 13, 1, 59, 5, 1, 3, 4)
arr -= 13 //删除数组中的元素，如果存在则删除，不存在不做操作
println(arr) // ArrayBuffer(6, 1, 59, 5, 1, 3, 4) 删除13
val newArr = arr.toArray
val buff = newArr.toBuffer
arr.foreach(println) // arr 的遍历
// 创建二维数组
val array: Array[Array[Int]] = Array.ofDim[Int](2, 3) //两行三列
array.foreach(_.foreach(println))
IndexedSeq
这种类型的主要访问方式是通过索引，默认的实现方式为 Vector
备注： 这里的IndexedSeq是immutable包下的，相关联的还有Array和String
val x = IndexedSeq(1, 2, 3)
println(x.getClass)
println(x(0))
val y = Range(1, 5)
println(y)
执行结果
class scala.collection.immutable.Vector
1
Range 1 until 5
LinearSeq
主要的区别在于其被分为头与尾两部分。其中，头是容器内的第一个元素，尾是除了头元素以外剩余的其他所有元素 。LinearSeq默认的实现是List，是不可变列表
val x = collection.immutable.LinearSeq("a", "b", "c")
println(x.head)
println(x.tail)
执行结果
a
List(b, c)
List
// 1. 创建一个List
val list1 = List(23, 65, 87)
// 2. 访问和遍历元素
println(list1(1))
// list1(1) = 12 //immutable包下的List没有update方法，即不能更改列表中的数据
list1.foreach(println)
// 3. 添加元素
val list2 = 10 +: list1
val list3 = list1 :+ 23
// 写成方法调用就是添加在前面，写成操作符的形式就添加在后面
val list4 = list2.::(51) //生成一个新的List，然后会把元素添加到list2开头，等价51 :: list2
println(list4)
val list5 = Nil.::(13)
println(list5)
val list7 = 17 :: 28 :: 59 :: 16 :: Nil // 常见创建列表的方法
println(list7)
// 4. 合并列表
val list9 = list5 ::: list7 // 等价于list7.:::(list5)
println(list9)
val list10 = list5 ++ list7 // 源码可以发现就是调用:::
println(list10)
ListBuff
相比于List，ListBuffer是可变的集合，可以添加，删除元素，属于scala.collection.mutable包下
// 1. 创建可变列表
val list1: ListBuffer[Int] = new ListBuffer[Int]() // 不推荐
val list2 = ListBuffer(12, 53, 75) //scala中推荐使用的构建方法，使用伴生对象的方式
// 2. 添加元素
list1.append(15, 62) // 后插
println(list1) // ListBuffer(15, 62)
list2.prepend(20) // 前插
println(list2) // ListBuffer(20, 12, 53, 75)
list1.insert(1, 19, 22) // 在索引1的位置添加19 22
println(list1) // ListBuffer(15, 19, 22, 62)
31 +=: 96 +=: list1 += 25 += 11 // 在lst1的前面添加元素31 96 在后面插入元素25 11
println(list1) // ListBuffer(31, 96, 15, 19, 22, 62, 25, 11)
// 3. 合并list
val list3 = list1 ++ list2 // 返回新的对象，list1和list2不变
println(list3) // ListBuffer(31, 96, 15, 19, 22, 62, 25, 11, 20, 12, 53, 75)
list1 ++= list2 // 在list1后添加list2的元素，list2不变，如果反过来就是list1 ++=: list2
println(list1) // ListBuffer(31, 96, 15, 19, 22, 62, 25, 11, 20, 12, 53, 75)
println(list2) // ListBuffer(20, 12, 53, 75)
// 4. 修改元素
list2(3) = 30 // 等价于 list2.update(3, 30)
// 5. 删除元素
list2.remove(2)
list2 -= 25
Set
与其他任何一种编程语言一样，Scala中的Set集合类具有如下特点：
i、不存在有重复的元素。
ii、集合中的元素是无序的。换句话说，不能以索引的方式访问集合中的元素。
iii、判断某一个元素是否在Set集合中比Seq类型的集合要快。
不可变的HashSet
val x = immutable.HashSet[String]("a", "c", "b")
//x.add("d")无法使用，因为是不可变集合，没有add方法。没有类似+=这样的操作
val y = x + "d" + "f" // 增加新的元素，生成一个新的集合
val z = y - "a" // 删除一个元素，生成一个新的集合
val a = Set(1, 2, 3)
val b = Set(1, 4, 5)
val c = a ++ b //合并集合
val d = a -- b // a中剔除b中的元素
val e = a & b // 与操作，交集
val f = a | b // 或操作，并集
可变的HashSet
val x = new mutable.HashSet[String]()
x += "a" // 添加一个新的元素。注意此时没有生成一个新的集合
x.add("d") //因为是可变集合，所以有add方法，返回值是boolean类型
x ++= Set("b", "c") // 添加一个新的集合，改变的是x，参照listBuffer
x.foreach(each => println(each))
x -= "b" // 删除一个元素，remove返回值也是boolean类型
val flag = x.contains("a") // 是否包含元素
println(flag)
不可变Map
Map这种数据结构是日常开发中使用非常频繁的一种数据结构。Map作为一个存储键值对的容器（key－value），其中key值必须是唯一的。 默认情况下，可以通过Map直接创建一个不可变的Map容器对象，这时候容器中的内容是不能改变的，在scala中，可以使用java相同的方式即(key,value)来标识键值对
// 两种创建map的方式
val peoples = Map("john" -> 19, "Tracy" -> 18, "Lily" -> 20) //不可变
val peopless = Map(("john", 19), ("Tracy", 18), ("Lily", 20))
// people.put("lucy",15) 会出错，因为是不可变集合。
//遍历方式1
for (p <- peoples) {
print(p + " ") // (john,19) (Tracy,18) (Lily,20)
}
//遍历方式2
peoples.foreach(x => {
val (k, v) = x; print(k + ":" + v + " ")
}) //john:19 Tracy:18 Lily:20
//遍历方式3
peoples.foreach({ case (k, v) => print(s"key: $k, value: $v ") })
//遍历方式4
for (key <- peoples.keys) {
println(s"$key ---> ${peoples.get(key)}") //scala中的map.get返回的是一个Optional类型
}
println(peoples("Lily")) //等价于get
可变的HashMap
val map = new mutable.HashMap[String, Int]()
map.put("john", 19) // 因为是可变集合，所以可以put
map += (("Tracy", 18)) // 增加，等价于put
map -= "john" // remove
map.contains("Lily") //false
map.foreach({ case (k, v) => println(s"key: $k, value: $v ") })
元组（元素组合）
元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据 。说的简单点，就是将多个无关的数据封装为一个整体，称为元组。Map 中的键值对其实就是元组,只不过元组的元素个数为 2，称之为对偶，二元元组
注意： 元组中最大只能有 22 个元素。
// 1. 创建元组
val tuple: (String, Int, Char, Boolean) = ("hello", 100, 'a', true)
println(tuple) // (hello,100,a,true)
// 2. 访问数据方式一
println(tuple._1)
println(tuple._2)
println(tuple._3)
println(tuple._4)
// 2. 访问数据方式二
println(tuple.productElement(0)) // 等价于_1，下标从零开始。
println(tuple.productElement(1)) // 等价于_2，下标从零开始。
println(tuple.productElement(2)) // 等价于_3，下标从零开始。
println(tuple.productElement(3)) // 等价于_4，下标从零开始。
// 3. 遍历元组数据
for (elem <- tuple.productIterator)
println(elem)
// 4. 嵌套元组
val mulTuple = (12, 0.3, "hello", (23, "scala"), 29)
println(mulTuple._4._2) // scala
// 对偶
val map = Map("a" -> 1, "b" -> 2, "c" -> 3)
map.foreach(tuple => {
println(tuple._1 + "=" + tuple._2)
})
队列
Scala 也提供了队列（Queue）的数据结构，队列的特点就是先进先出。进队和出队的方法分别为 enqueue 和 dequeue
val que = new mutable.Queue[String]()
que.enqueue("a", "b", "c")
println(que.dequeue()) //a
println(que.dequeue()) //b
println(que.dequeue()) //c
集合常用函数
基本属性和常用操作
val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7)
//获取集合长度
println(list.length)
//获取集合大小
//有些集合（比如Set）可能没有length方法，在LinearSeq中等同于 length
val x = collection.immutable.LinearSeq("a", "b", "c")
println(x.size)
//循环遍历
list.foreach(println)
//迭代器
for (elem <- list.iterator) {
println(elem)
}
//生成字符串
println(list.mkString(","))
//是否包含
println(list.contains(3))
衍生集合函数
val list1: List[Int] = List(1, 2, 3, 4, 5, 6, 7)
val list2: List[Int] = List(4, 5, 6, 7, 8, 9, 10)
//（1）获取集合的头
println(list1.head)
//（2）获取集合的尾（不是头的就是尾）
println(list1.tail)
//（3）集合最后一个数据
println(list1.last)
//（4）集合初始数据（不包含最后一个）
println(list1.init)
//（5）反转
println(list1.reverse)
//（6）取前（后）n 个元素
println(list1.take(3))
println(list1.takeRight(3))
//（7）去掉前（后）n 个元素
println(list1.drop(3))
println(list1.dropRight(3))
//（8）并集
println(list1.union(list2)) // 等价于：++
//（9）交集
println(list1.intersect(list2))
//（10）差集
println(list1.diff(list2))
//（11）拉链操作：如果两个集合的元素个数不相等，那么会将同等数量的数据进行拉链，多余的数据省略不用，返回一个List，其组成元素是二元组
println(list1.zip(list2))
//（12）滑窗
list1.sliding(3, 3).foreach(println) // 返回值类型：Iterator[List[Int]]
// sliding的第一个参数定义窗口的长度，第二个参数定义滑动的步长，当窗口长度和步长相等时称为滚动，如果窗口长度小于步长将造成数据丢失
集合计算简单函数
val list: List[Int] = List(1, 5, -3, 4, 2, -7, 6)
val map = Map(("john", 19), ("Tracy", 18), ("Lily", 20))
//（1）求和
println(list.sum)
//（2）求乘积
println(list.product)
//（3）最大值
println(list.max)
//以后看到actionBy名字的方法，同时通过某种自定义函数的结果去执行action方法。
println(map.maxBy(_._2)) //("Lily", 20)
//（4）最小值
println(list.min)
println(map.minBy(_._2)) //("Tracy", 18)
//（5）排序
// （5.1）按照元素大小排序
println(list.sortBy(x => x))
println(list.sorted.reverse) //倒序，list里的reverse
println(list.sorted(Ordering[Int].reverse)) //倒序，Ordering里的reverse
// （5.2）按照元素的绝对值大小排序
println(list.sortBy(x => x.abs))
// （5.3）按元素大小升序排序
println(list.sortWith((x, y) => x < y))
// （5.4）按元素大小降序排序
println(list.sortWith((x, y) => x > y))
备注：
（1）sorted：对一个集合进行自然排序，可以传递隐式的 Ordering
（2）sortBy：通过指定的属性进行排序，通过它的类型。可以传递隐式的 Ordering
def sortBy[B](f: A => B)(implicit ord: Ordering[B]): Repr = sorted(ord on f)
（3）sortWith：基于函数的排序，通过一个 comparator 函数，实现自定义排序的逻辑。
def sortWith(lt: (A, A) => Boolean): Repr = sorted(Ordering fromLessThan lt)
集合计算高级函数
val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
val wordList: List[String] = List("hello world", "hello spark", "hello scala")
//（1）过滤
println(list.filter(x => x % 2 == 0)) // list.filter(_ % 2 == 0)
//（2）转化/映射
println(list.map(x => x + 1)) // list.map(_ + 1)
//（3）扁平化 将嵌套list 展开成一个list
println(nestedList.flatten) //List(1, 2, 3, 4, 5, 6, 7, 8, 9)
//（4）扁平化+映射 注：flatMap 相当于先进行 map 操作，在进行 flatten操作，集合中的每个元素的子元素映射到某个函数并返回新集合
println(wordList.flatMap(x => x.split(" "))) // List(hello, world, hello, spark, hello, scala)
//（5）分组：按照指定的规则对集合的元素进行分组
println(list.groupBy(x => x % 2)) //Map(1 -> List(1, 3, 5, 7, 9), 0 -> List(2, 4, 6, 8))
// Map(奇数 -> List(1, 3, 5, 7, 9), 偶数 -> List(2, 4, 6, 8))
println(list.groupBy(data => if (data % 2 == 0) "偶数" else "奇数"))
//（6）Reduce 简化（归约） ：通过指定的逻辑将集合中的数据进行聚合，从而减少数据，最终获取结果。
// 将数据两两结合，实现运算规则
val ii: Int = list.reduce((x, y) => x - y) //list.reduce(_ - _ )
println("ii = " + ii)
// 从源码的角度，reduce 底层调用的其实就是 reduceLeft
// 1-2=-1 -1-3=-4 -4-4=-8.....
val i1 = list.reduceLeft((x, y) => x - y)
println(i1)
// 9-8=1 1-7=-6 -6-6=-12....
val i2 = list.reduceRight((x, y) => x - y)
println(i2)
//（7）Fold 折叠：化简的一种特殊情况。
// fold 方法使用了函数柯里化，存在两个参数列表，第一个参数列表为 ： 零值（初始值），第二个参数列表为： 简化规则。fold 底层其实为 foldLeft
val i = list.foldLeft(1)((x, y) => x - y)
val i3 = list.foldRight(10)((x, y) => x - y)
// 两个 Map 的数据合并
val map1 = mutable.Map("a" -> 1, "b" -> 2, "c" -> 3)
val map2 = mutable.Map("a" -> 4, "b" -> 5, "d" -> 6)
val map3: mutable.Map[String, Int] = map2.foldLeft(map1) {
(map, kv) => {
val k = kv._1
val v = kv._2
map(k) = map.getOrElse(k, 0) + v
map
}
}
println(map3) // Map(b -> 7, d -> 6, a -> 5, c -> 3)