scala中集合的基本操作

scala的集合有三大类:序列Seq,集Set,映射Map.所有的集合都扩展自Iterable特质,在scala中集合分为可变(mutable)和不可变(immutable)两种类型,immutable类型集合初始化不能改变

变长集合

ArrayBuffer是可变长度的数组 Array是不可变数组

ListBuffer是可变长的集合,List是不可变的

HashMap是可变的,Map是不可变的,map中添加元素 key -> value

Nil 是可以空的list

Seq序列

::

操作符是给定的头和尾创建一个新的列表

scala> 100 :: Nil
res0: List[Int] = List(100)

val list1 = List(1,2)
 1::list1
 res1: List[Int] = List(1, 1, 2) //结果

+:

把:看成元素本身

scala> 3 +: list1
res2: List[Int] = List(3, 1, 2)

:+

scala> list1 :+ 3 
res3: List[Int] = List(1, 2, 3)

集合的常用方法

sorted

排序(默认是升序)

sortBy

排序(x => x) 如果x正数则是升序,负数为降序

sortWith

元祖里面的元素进行比较

grouped

一组结合

scala> list1.grouped(2).toList
res4: List[List[Int]] = List(List(1, 2), List(4))

scala> list1.grouped(1).toList
res5: List[List[Int]] = List(List(1), List(2), List(4))

scala> list1.grouped(3).toList
res6: List[List[Int]] = List(List(1, 2, 4))

fold

折叠,作为一个初始值传入

scala> val list1 = List(1,2,4)
list1: List[Int] = List(1, 2, 4)
scala> list1.fold(2)((x,y) => x+y)
res1: Int = 9

底层是调用了foldLeft

每次处理结果为被除数或者被减数

foldright 每一次处理后结果为减数或者除数

reduce

聚合

scala> val list1 = List(1,2,4)
scala> list1.reduce(_+_)

aggregate

聚合的意思,非并行情况下底层调用的是foldLeft

def aggregate[B](z: B)(seqop: (B, A) => B, combop: (B, B) => B): B
scala> list1.aggregate(2)(_+_,_+_)
res10: Int = 9

交并差集

union : 将两个集合合并,intersect : 两个结合的交集 diff : A相对于B的差集

head,tail

头和尾

zip

scala> val list1 = List(1,2,3)
scala> val list2 = List(4,5)
scala> list1.zip(list2)
res0: List[(Int, Int)] = List((1,4), (2,5))

scala> list2.zip(list1)
res1: List[(Int, Int)] = List((4,1), (5,2))
相同位置的合并,多余的舍去

小提示 可以后期用map(_.1+__.2)

mkString

将集合按照指定字符隔开

scala> list1.mkString("~")
res2: String = 1~2~3

slice

定位到数组的位置,左闭右开

scala> list1
res11: List[Int] = List(1, 2, 3)
scala> list1.slice(1,list1.length))
res12: List[Int] = List(2, 3)

sum

要求全是sum

scala> list2.sum
res13: Int = 9

重点掌握

map,flatten,flatMap,fliter,sortBy,sortWith,foldLeft,aggregate,zip