快学Scala第13章----集合
来源:互联网 发布:北京it系统集成商 编辑:程序博客网 时间:2024/06/07 08:20
本章要点
- 所有集合都扩展自Iterable特质
- 集合有三大类:序列、集、映射
- 对于几乎所有集合类,Scala都同时提供了可变的和不可变的版本
- Scala列表要么是空的,要么拥有一头一尾,其中尾部本身又是一个列表
- 集是无先后次序的集合
- 用LinkedhashSet 来保留插入顺序,或者用SortedSet来按顺序进行迭代
- ‘+’ 将元素添加到无先后次序的集合中; +: 和 :+ 向前或向后追加到序列; ++将两个集合串接在一起; -和–移除元素
- Iterable和Seq特质有数十个用于常见操作的方法
- 映射、折叠和拉链操作是很有用的技巧,用来将函数或操作应用到集合中的元素
主要的集合特质
Scala集合继承层级中的关键特质:
Iterable值的是那些能申城用来访问集合中所有元素的Iterator的集合,类似于C++的迭代器。
val coll = ... //某种Iterableval iter = coll.iteratorwhile (iter.hasNext) { 对iter.next() 执行某种操作}
Seq是一个有先后次序的值的序列,例如数字或列表。IndexedSeq允许我们通过使用下标的方式快速访问元素。
Set是一组没有先后次序的值的集合。在SortedSet中,元素是排序的。
Map是一组(key, value)对偶。 SortedMap按照键的排序的。
每个Scala集合特质或类都有一个带有apply方法的伴生对象,这个apply方法可以用来构建该集合的实例,而不用使用new,这样的设计叫做”统一创建原则”。
可变和不可变集合
Scala同时支持可变和不可变的集合。Scala优先采用不可变集合,因此你可以安全的共享其引用。任何对不可变集合的修改操作都返回的是一个新的不可变集合,它们共享大部分元素。
def digits(n: Int): Set[Int] = { if (n < 0) digits(-n) else if (n < 10) Set(n) else digits(n / 10) + (n % 10)}
这个例子利用递归不断的产生新的集合,但是要注意递归的深度。
序列
最重要的不可变序列:
Vector是ArrayBuffer的不可变版本,和C++的Vector一样,可以通过下标快速的随机访问。而Scala的Vector是以树形结构的形式实现的,每个节点可以有不超过32个子节点。这样对于有100万的元素的向量而言,只需要4层节点。
Range表示一个整数序列,例如0,1,2,3,4,5 或 10,20,30 . Rang对象并不存储所有值而只是起始值、结束值和增值。
最有用可变序列:
列表
在Scala中,列表要么是Nil(空列表),要么是一个head元素加上一个tail,而tail又是一个列表。例如:
val digits = List(4,2)digits.head // 4digits.tail // List(2)digits.tail.head // 2digits.tail.tail // Nil
:: 操作符从给定的头和尾创建列表:
9 :: List(4, 2) // List(9,4,2)// 等同于9 :: 4 :: 2 :: Nil // 这里是又结合的
遍历链表:可以使用迭代器、递归或者模式匹配
def sum(lst: List[Int]): Int = { if (lst == Nil) 0 else lst.head + sum(lst.tail)}def sum(lst: List[Int]): Int = lst match { case Nil => 0 case h :: t => h + sum(t)}
可变列表
可变的LinkedList既可以修改头部(对elem引用赋值),也可以修改尾部(对next引用赋值):
val lst = scala.collection.mutable.LinkedList(1, -2, 7, -9)// 修改值var cur = lstwhile (cur != Nil) { if (cur.elem < 0) cur.elem = 0 cur = cur.next}// 去除每两个中的一个var cur = lstwhile (cur != Nil && cur.next != Nil) { cur.next = cur.next.next cur = cur.next}
注意: 如果你想要将列表中的某个节点变成列表的最后一个节点,你不能够将next引用设为Nil,而应该将next引用设为LinkedList.empty。也不要设为null,不然在遍历该链表时会遇到空指针错误。
集
集是不重复的元素的集合,与C++中的set相同。集并不保留元素插入的顺序,默认情况下,集以哈希集实现。
而链式哈希集可以记住元素插入的顺序,它会维护一个链表来达到这个目的。
val weekdays = scala.collection.mutable.LinkedHashSet("Mo", "Tu", "We", "Th", "Fr")
对于SortedSet已排序的集使用红黑树实现的。Scala没有可变的已排序的集,前面已经讲过。
集的一些常见操作:
val digits = Set(1,7,2,9)digits contains 0 // falseSet(1, 2) subsetOf digits // trueval primes = Set(2,3,5,7)digits union primes // Set(1,2,3,5,7,9)// 等同于digits | primes // 或 digits ++ primesdigits intersect primes // Set(2, 7)// 等同于digits & primesdigits diff primes // Set(1, 9)// 等同于digits -- primes
用于添加或去除元素的操作符
一般而言, + 用于将元素添加到无先后次序的集合,而+: 和 :+ 则是将元素添加到有先后次序的集合的开头或是结尾。
Vector(1,2,3) :+ 5 // Vector(1,2,3,5)1 +: Vector(1,2,3) // Vector(1,1,2,3)
常用方法
Iterable特质最重要的方法:
Seq特质在Iterable特质的基础上又增加的一些方法:
将函数映射到集合
map方法可以将某个函数应用到集合的每一个元素并产出其结果的集合。例如:
val names = List("Peter", "Paul", "Mary")names.map(_.toUpperCase) // List("PETER", "PAUL", "MARY")// 等同于for (n <- names) yield n.toUpperCase
如果函数产出一个集合而不是单个值得话,则使用flatMap将所有的值串接在一起。例如:
def ulcase(s: String) = Vector(s.toUpperCase(), s.toLowerCase())names.map(ulcase) // List(Vector("PETER", "peter"), Vector("PAUL", "paul"), Vector("MARY", "mary"))names.flatmap(ulcase) // List("PETER", "peter", "PAUL", "paul", "MARY", "mary")
collect方法用于偏函数—并没有对所有可能的输入值进行定义的函数。例如:
"-3+4".collect {case '+' => 1; case '-' => -1} // Vector(-1,1)"-3+4".collect {case '-' => -1} // Vector(-1)"-3+4".collect {case '+' => 1} // Vector(1)"-3+4".collect {case '*' => 1} // Vector()
foreach方法将函数应用到各个元素但不关心函数的返回值。
names.foreach(println)
化简、折叠和扫描
reduceLeft、reduceRight、foldLeft、foldRight、scanLeft、scanRight方法将会用二元函数来组合集合中的元素:
List(1,7,2,9).reduceLeft(_ - _) // ((1 - 7) - 2) - 9List(1,7,2,9).reduceRight(_ - _) // 1 - (7 - (2 - 9))List(1,7,2,9).foldLeft(0)(_ - _) // 0 - 1 -7 - 2 - 9List(1,7,2,9).foldRight(0)(_ - _) // 1 - (7 - (2 - (9 - 0)))(1 to 10).scanLeft(0)(_ + _) // Vector(0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55)
拉链操作
前面的章节已经讲过拉链操作。除了zip方法外,还有zipAll和zipWithIndex方法
List(5.0, 20,0, 9.7, 3.1, 4.3).zipAll(List(10, 2), 0.0, 1) // List((5.0, 10), (20.0, 2), (9.7, 1), (3.1, 1), (4.3, 1))"Scala".zipWithIndex // Vector(('S', 0), ('c', 1), ('a', 2), ('l', 3), ('a', 4) )
迭代器
迭代器的好处就是你不用将开销很大的集合全部读进内存。例如读取文件操作,Source.fromFile产出一个迭代器,使用hasNext和next方法来遍历:
while (iter.hasNext) 对 iter.next() 执行某种操作
这里要注意迭代器多指向的位置。在调用了map、filter、count、sum、length等方法后,迭代器将位于集合的尾端,你不能再继续使用它。而对于其他方法而言,比如find或take,迭代器位于已经找到元素或已取得元素之后。
流
流是一个尾部被懒计算的不可变列表—–也就是说,只有当你需要时它才会被计算。
def numsFrom(n: BigInt): Stream[BigInt] = n #:: numsFrom(n + 1)val tenOrMore = numsFrom(10) // 得到一个 Stream(10, ?) 流对象,尾部未被求值temOrMore.tail.tail.tail // Stream(13, ?)
流的方法是懒执行的。例如:
val squares = numsFrom(1).map(x => x * x) // 产出 Stream(1, ?)// 需要调用squares.tail来强制对下一个元素求值squares.tail // Stream(4, ?)// 使用take和force强制求指定数量的值squares.take(5).force // Stream(1,4,9,16,25)
注意: 不要直接使用 squares.force, 这样将会是一个无穷的流的所有成员求值, 引发OutOfMemoryError 。
懒视图
应用view方法也可以实现懒执行,该方法产出一个其方法总是被懒执行的集合。例如:
val powers = (0 until 1000).view.map(pow(10, _))powers(100) //pow(10, 100)被计算,其他值的幂没有被计算
和流不同,view连第一个元素都不求值,除非你主动计算。view不缓存任何值,每次调用都要重新计算。
懒集合对于处理以多种方式进行变换的大型集合很有好处,因为它避免了构建出大型中间集合的需要。例如:
(0 to 1000).map(pow(10, _)).map(1 / _) // 1(0 to 1000).view.map(pow(10, _)).map(1 / _).force // 2
第一个式子 会产出两个集合,第一个集合的每一个元素是pow(10, n),第二个集合是第一个集合中每个集合中的元素取倒数。 而第二个表达式使用了视图view,当动作被强制执行时,对每个元素,这两个操作是同时执行的,不需要额外构建中间集合。
与Java集合的互操作
线程安全的集合
Scala类库提供了六个特质,你可以将它们混入集合,让集合的操作变成同步:
SynchronizedBuffer
SynchronizedMap
SynchronizedPriorityQueue
SynchronizedQueue
SynchronizedSet
SynchronizedStack
例如:
val scores = new scala.collection.mutable.HashMap[String, Int] with scala.collection.mutable.SynchronizedMap[String, Int]
当然,还有更高效的集合,例如ConcurrentHashMap或ConcurrentSkipListMap,比简单的用同步方式执行所有的方法更为有效。
并行集合
集合的par方法产出当前集合的一个并行实现,例如sum求和,多个线程可以并发的计算不同区块的和,在最后这部分结果被汇总到一起。
coll.par.sum
你可以通过对要遍历的集合应用par并行for循环
for(i <- (0 until 100).par) print(i + " ")
而在 for/yield循环中,结果是依次组装的:
for(i <- (0 until 100).par) yield i + " "
这里要注意变量是共享变量,还是循环内的局部变量:
var count = 0for (c <- coll.par) {if (c % 2 == 0) count += 1} // error
**注意: **par方法返回的并行集合的类型为扩展自ParSeq、ParSet或ParMap特质的类型,所有这些特质都是ParIterable的子类型。这些并不是Iterable的子类型,因此你不能将并行集合传递给预期Iterable、Seq、Set、Map方法。你可以用ser方法将并行集合转换回串行集合,也可以实现接受通用的GenIterable、GenSeq、GenSeq、GenMap类型的参数的方法。
说明: 并不是所有的方法都可以被并行化。例如reduceLeft、reduceRight要求每个操作符按照顺序先后被应用。
- 快学Scala第13章----集合
- 《快学Scala》 第1章 基础
- 快学Scala第1章--基础
- 快学Scala第5章--类
- 快学Scala第6章--对象
- 快学Scala第8章----继承
- 快学Scala第10章----特质
- 快学Scala第15章----注解
- 快学Scala第20章----Actor
- 【书山有路】快学Scala 第1章
- 【快学Scala】第 1 章 基础
- 快学Scala-元祖、集合
- 快学Scala习题解答—第十三章 集合
- 快学Scala习题解答第十三章---------集合
- 快学Scala习题解答—第十三章 集合
- 《快学Scala》第1章 基础 练习
- 《快学Scala》第3章 数组相关操作 练习
- 《快学Scala》第5章 类 练习
- 删除xcode里的描述文件
- World CodeSprint #4[HackerRank]
- 微信paxos类库PhxPaxos实现原理与解析
- mac下hadoop 2.6.0编译native library
- 量化-windows下如何安装Python、pandas
- 快学Scala第13章----集合
- 提高项目12.5-数组大折腾
- ACM总结体会
- Android中的自定义注解
- hibernate_Restrictions用法 hibernate_Restrictions用法
- 更新BLE的设备后,OSX LightBlue 不会更新扫描到Service
- 数据结构——c语言描述 第四章 字符串
- 用可视化修改layer层
- Which machine learning algorithms can be considered as among the best?