scala的集合

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 commaprintln(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,aendList(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,73println(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.iteratorwhile (iter.hasNext)println(iter.next())

 update 方法

当对带有括号并包括一到若干参数的对象进行赋值时，编译器将使用对象的 update 方法对括号里的参数和等号右边的对象执行调用

object Third {def main(args: Array[String]): Unit = {val obj = new SomeClassval 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 上添加元素，而是新生成一个ArrayBufferval newArr1 = arr :+ 2println(arr == newArr1) //falseval newArr2 = arr += 3 //元素加在数组最后面println(arr == newArr2) //truenewArr2 += 4println(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 59arr.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)  删除13val newArr = arr.toArrayval buff = newArr.toBufferarr.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. 创建一个Listval list1 = List(23, 65, 87)// 2. 访问和遍历元素println(list1(1))//    list1(1) = 12  //immutable包下的List没有update方法，即不能更改列表中的数据list1.foreach(println)// 3. 添加元素val list2 = 10 +: list1val list3 = list1 :+ 23// 写成方法调用就是添加在前面，写成操作符的形式就添加在后面val list4 = list2.::(51) //生成一个新的List，然后会把元素添加到list2开头，等价51 :: list2println(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 22println(list1) // ListBuffer(15, 19, 22, 62)31 +=: 96 +=: list1 += 25 += 11   // 在lst1的前面添加元素31  96 在后面插入元素25 11println(list1) // ListBuffer(31, 96, 15, 19, 22, 62, 25, 11)// 3. 合并listval 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 ++=: list2println(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，参照listBufferx.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) 会出错，因为是不可变集合。//遍历方式1for (p <- peoples) {print(p + "  ") // (john,19)  (Tracy,18)  (Lily,20)}//遍历方式2peoples.foreach(x => {val (k, v) = x; print(k + ":" + v + "  ")}) //john:19  Tracy:18  Lily:20//遍历方式3peoples.foreach({ case (k, v) => print(s"key: $k, value: $v  ") })//遍历方式4for (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) // 因为是可变集合，所以可以putmap += (("Tracy", 18))  // 增加，等价于putmap -= "john" // removemap.contains("Lily") //falsemap.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())   //aprintln(que.dequeue())   //bprintln(que.dequeue())   //c

集合常用函数

基本属性和常用操作

val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7)//获取集合长度
println(list.length)
//获取集合大小
//有些集合（比如Set）可能没有length方法，在LinearSeq中等同于 lengthval 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里的reverseprintln(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 展开成一个listprintln(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 底层其实为 foldLeftval 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._1val v = kv._2map(k) = map.getOrElse(k, 0) + vmap}}println(map3) // Map(b -> 7, d -> 6, a -> 5, c -> 3)