一、主要的集合特质
Seq有先后顺序的序列，如数组列表。IndexedSeq通过下标快速的访问元素。不可变：Vector, Range, List 可变：ArrayBuffer, LinkedList
Set一组没有先后顺序的集合，SortedSet排过序的顺序被访问。
Map一组(键，值)对，SortedMap按照键的排序访问值。
+ 用于将元素添加到无次序的集合中，:+ 和 +: 用于将元素添加到有次序的集合中
++无序集合添加无序集合 ++: 有序集合添加有序集合
::: 列表添加列表
:: 列表添加元素
每个scala集合特质或类都有一个带apply方法的伴生对象，用来构建集合中的实例。
Iterator(0xFF,0xFFFF,0xFF00).foreach(println(_)) SortedSet("world","hello").foreach(println(_)) Map(1 -> "First",2 -> "Second",3 -> "Third")
二、可变和不可变集合
import scala.collection.immutable.Map //不可变 map import scala.collection.mutable.Map //可变 map
三、序列
不可变序列：Vector,Range
可变序列：ArrayBuffer
ArrayBuffer:
四、列表
/* * 四、列表 * 不可变列表 List * 可变列表 LinkedList * * Nil空表 * digits.head, digits.tail * * 不可变列表 元素遍历 list.tail 使用递归调用 * 可变列表 元素遍历 list.elem 循环lsit.next * ::添加元素 右结合 从末端开始构建，在表头进行插入 * :::批量添加元素，两个列表相加 * */ val digits = List(4,2) println(digits.head) println(digits.tail) val d1 = 3 :: digits //::右结合， 从末端开始构建，就是在表头进行插入 println(d1) val d2 = d1:+8 println(d2) //递归调用，遍历List def sum(lst:List[Int]): Int ={ if (lst == Nil) 0 else lst.head + sum(lst.tail) } println(sum(d1)) //模式匹配，递归调用 遍历List def sum1(lst:List[Int]):Int = lst match{ case Nil =>0 case h::t => h + sum1(t) // ::表示析构 将列表析构成表头和表尾 } println(sum1(d1)) //可变列表，通过 .elem获取元素值并进行修改，通过.next进行后移 val lst = scala.collection.mutable.LinkedList(1,2,-1,-4,6) var cur = lst while(cur != Nil){ if(cur.elem < 0) cur.elem = 0 cur = cur.next }
五、可变列表
如上
六、集
/* * 四、集 * Set 不重复元素的集合 * Set 集合分为可变的和不可变的集合。 * */ //集 添加元素 1 由于存在，结果不变 val s = Set(1,0,2)+1 println(s) //集合顺序 val set = Set(1,2,3,4,5)+6 for(i<- set){ print(i+" ") //查询结果顺序 5 1 6 2 3 4 顺序不是插入顺序，顺序是根据值的hashCode进行组织的 };println() //已经排序的集 val set1 = scala.collection.mutable.SortedSet(1,2,3,4,5) for(i<-set1){ print(i+" ") };println()
七、用于添加或去除元素的操作符
/* * 添加删除元素的操作符 * + 无序集合添加元素 * :+ 有序集合添加元素 * - 移除元素 * ++ --批量增加删除 * ::,::: 列表 优先使用 * */ //向量 不可变 返回新的集合 val v1 = Vector(1,2,3) :+ 5 // :+ 右加元素 println(v1) var v2 = 0 +: v1 // +: 左加元素 var v3 = v1 ++ v2 // ++ 两个集合相加，返回新的集合 println(v2) println(v3) //ArrayBuffer 可变 var num1 = ArrayBuffer(1,2,3,4) :+ 4 // :+ 右加元素 返回新的集合 var num2 = ArrayBuffer(11,22,33) num1 += 2 // += 增加元素，修改集合 num1 -= 2 // -= 删除元素，从头开始 num1 ++= num2 // ++= 两个集合相加 println(num1) println(num2) //Set |并集 &交集 &~差集 val s1 = scala.collection.immutable.Set(1,0,2,3) val s2 = scala.collection.mutable.Set(2,3,4,5) val s3 = s1 + 1 // 无序使用 + val s4 = s1 | s2 // 并集 等同于++ val s5 = s1 & s2 // 交集 val s6 = s1 &~ s2 // 差集 属于s1不属于s2 等同于-- var s7= s2 &~ s1 // 差集 属于s2不属于s1 等同于-- s2 -= 4 //-= 删除元素内容 //s1 -= 1 //报错， 不可变集合 println(s2) println(s3) println(s4) println(s5) println(s6) println(s7)
八、常用方法
九、将函数映射到集合
/* * 将函数映射到集合 * map, flatMap, foreach... * * */ //map val name = List("Jim","Rob","Tom") println(name.map(_.toUpperCase)) //flatMap def as(s:String) = List(s.toUpperCase,s.toLowerCase()) println(name.flatMap(as)) //foreach name.foreach(println) //collect val col= "+4-3".collect{case '+'=> 1;case '-'=> -1; case _ => 0} println(col)
List(JIM, ROB, TOM)
List(JIM, jim, ROB, rob, TOM, tom)
Jim
Rob
Tom
Vector(1, 0, -1, 0)
十、化简、折叠和扫描
/* * 十、化简、折叠和扫描 * reduce * fold * scan * */ //reduceLeft 从左侧两元素互操作 1-7-2-9 -17 val li = List(1,7,2,9) var re =li.reduceLeft(_ - _) println(re) //reduceRight 从右侧两元素互操作 (1-(7-(2-9))) -13 re = li.reduceRight(_-_) println(re) //foldLeft 初始值为0，从左侧开始 0-1-7-2-9 -19 val f = List(1,7,2,9) var re1 = f.foldLeft(0)(_-_) println(re1) //foldRight 初始值为0，从右侧开始 (1-(7-(2-(9-0)))) -13 re1 = f.foldRight(0)(_-_) println(re1) // /: 表示 foldLeft :\ 表示 foldRight 树： 树的左侧/: 树的右侧:\ val f1 = (0 /: List(1,7,2,9))(_-_) val f2 = (List(1,7,2,9) :\ 0)(_-_) println(f1) println(f2) //计算字符串中字母出现的频率 //方法1：通过可变map循环字符串，累加计数进行计算 val freq = scala.collection.mutable.Map[Char,Int]() for(c<- "Mississippi"){ freq(c) = freq.getOrElse(c,0) + 1 };println(freq) //方法2：通过foldLeft对数据进行计算， val m1 = (Map[Char,Int]() /: "Mississippi"){ (m, c) => m + (c -> (m.getOrElse(c,0)+1)) //m代表map, c代表字符 每次一个字符进来持续计算，然后结果加入到map中，然后返回map };println(m1) //scanLeft scanRight 得到计算中间结果 val ran = (1 to 10).scanLeft(0)(_+_) println(ran) //Vector(0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55)
-17 -13 -19 -13 -19 -13 Map(M -> 1, s -> 4, p -> 2, i -> 4) Map(M -> 1, i -> 4, s -> 4, p -> 2) Vector(0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55)
十一、拉链操作
/* * 十一、拉链 * zip * zipAll * zipWithIndex * */ //zip val prices = List(5.0, 20.0, 9.95) val quantities = List(10, 2) println(prices.zip(quantities)) println(prices.zip(quantities).map{p=>(p._1 * p._2)}) //zipWithIndex println("Scala".zipWithIndex) //zipAll println(prices.zipAll(quantities,0,1)) //全部zip,缺少元素使用默认值；that 少用0，this 少用1 println("Scala".zipWithIndex.max) println("Scala".zipWithIndex.max._2)
List((5.0,10), (20.0,2)) List(50.0, 40.0) Vector((S,0), (c,1), (a,2), (l,3), (a,4)) List((5.0,10), (20.0,2), (9.95,1)) (l,3) 3
十二、迭代器
十三、流
十四、懒视图
十五、与Java集合的互操作
十六、线程安全的集合
十七、并行集合
参考《快学Scala》
