Scala集合(二)

将函数映射到集合

map方法

val names = List("Peter" , "Paul", "Mary")

names.map(_.toUpperCase) // 等同于 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 方法用于 partial function,那些并没有对所有可能的输入值进行定义的函数, 产出被定义的所有参数的函数值得集合

"-3+4".collect(case '+' -> 1; case '-' -> -1) // vector(-1,1)

foreach方法

names.foreach(println)

化简、折叠和扫描 

List(1,7,2,9).reduceLeft(_ - _) 

( ( 1 - 7 ) - 2 ) - 9 = 1- 7 - 2 - 9 = -17

List(1,7,2,9).reduceRight(_ - _) 

1 - ( 7 - ( 2 - 9  ) ) = 1-7 + 2 -9 = -13

以不同首元素开始计算

List(1,7,2,9).foldLeft(0)(_ - _)

0-1-7-2-9 = -19

List(1,7,2,9).foldLeft(" ")(_ + _) // 由柯里化判断第二个参数类型定义(String, Int) => String

" " +1 + 7+2+9 = " 1729"

(0 /: List(1,7,2,9))(_ - _) //  /: 操作符代替了foldLeft操作

Scala 也提供了foldRight 和 :\的变体
折叠有时可以代替循环,比如计算字母出现频率

val freq = scala.collection.mutable.Map[Char, Int]() // 可变映射

for( c <- "Mississippi") 

  freq(c) =freq.getOrElse(c,0)+1 // Map('i' ->4, 'M' -> 1, 's' -> 4, 'p' ->2)

折叠实现

(Map[Char, Int]() /:"Mississippi"){

  (m,c) => m + (c -> (m.getOrElse(c,0) +1)

}// 这里的 Map是不可变,每次计算出一个新的Map

scanLeft,scanRight, 得到包含所有中间结果的集合

(1 to 10).scanLeft(0)(_ + _)

Vector(0,1,3,6,10,15,21,28,36,45,55)

拉链操作 

zip

val prices = List(5.0,20.0,9.95) // 价格

val quantities = List(10,2,1)     //数量

prices zip quantities 得到一个List[(Double, Int)] , 一个个对偶的列表

List[(Double, Int)] = List( (5.0, 10), (20.0, 2 ), (9.95, 1))

计算总价

((prices zip quantities) map {p => p._1 * p._2}) sum

如果两个集合数量不一致

List( 5.0, 20.0, 9.95 ) zip List(10, 2) // List((5.0, 10), (20.0, 2))

zipAll 指定短列表的缺省值:第二个参数补充左边,第三个参数补充右边

List(1,1).zipAll(List(2),6,7) // List((1,2),(1,7))

List(1).zipAll(List(2,3),6,7)// List((1,2), (3,6))

zipWithIndex, 返回对偶列表,第二个组成部分是元素下标

"Scala".zipWithIndex // Vector(('S',0),('c',1),('a',2),('l',3),('a',4))

求最大编码的值得下标为

"Scala".zipWithIndex.max._2

迭代器 (相对于集合而言是一个“懒”的替代品,只有在需要时才去取元素,如果不需要更多元素,不会付出计算剩余元素的代价) 

对于那些完整构造需要很大开销的集合,适合用迭代器

如Source.fromFile产出一个迭代器,因为整个文件加载进内存不高效。

迭代器的两种用法

while(iter.hasNext)

  iter.next()

for(elem <- iter)

  对elem操作

上述两种循环都会讲迭代器移动到集合末端,不能再被使用,

调用 map filter count sum length方法后, 迭代器也会位于集合的末端,不能使用

find 或 take ,迭代器位于找到的元素之后

流(stream) 

迭代器每次调用next都会改变指向,

如果要缓存之前的值,可以使用流

流是一个尾部被懒计算的不可变列表,也就是说只有需要时才计算

def numsForm(n:BigInt) : Stream[BigInt] = n #:: numsForm(n+1) // #:: 操作符 构建出来的是一个流

var tenOrMore = numsForm(10) // Stream(10,?), 其尾部是未被求值得

tenOrMore.tail.tail.tail // Stream(13,?)

val squares = numsForm(1).map{ x=> x*x) // Stream(1,?)

take 可以一次获得多个值, force强制求值

squares.take(5).force // Stream(1,4,9,16,25)

squares.force // 会尝试对一个无穷流的所有成员求值,最后OutOfMemoryError

迭代器可以用来构造一个流

Source.getLines返回一个Iterator[String],用这个迭代器,对于每一行只能访问一次,而流将缓存访问过的行,允许重新访问

val words = Sourcce.fromFile("/usr/share/dict/words").getLines.toStream

words // Stream(A, ?)

words(5) // Aachen

words // Stream(A, A'o, AOL, AOL's, Aachen, ?)

懒视图(应用于集合) 

类似流的懒理念

与流的不同

1、连第一个元素都不会求值

2、不会缓存求过的值

val powers = (0 unti 1000).view.map(pow(10,_))

powers(100) // pow(10,100)被计算,其他值未计算,同时也不缓存,下次pow(10,100)将重新计算

force方法可以对懒视图强制求值,得到与原集合相同类型的新集合,

懒视图的好处:可以避免在多种变换下产生的中间集合

(0 to 1000).map(pow(10,_)).map(1/_) //先第一个map,再第二个map, 构建了一个中间集合

(0 to 1000).view.map(pow(10,_)).map(1/_).force // 记住两个map操作,每个元素被两个操作同时执行,不需要额外构中间集合

与Java集合的互操作

import scala.collection.JavaConversions._

val props:scala.collection.mutable.Map[String,String] = System.getProperties()

如果担心那些不需要的隐式转换也被引入的话,只引入需要的即可

import scala.collection.JavaConversions.propertiesAsScalaMap

这些转换产出的是包装器,让你可以使用目标接口来访问原本的值

props("name") = "clat" //props既是包装器

包装器将调用底层Properties对象的put("name","clat")

线程安全的集合

Scala类库提供了六个特质,将他们混入集合,让集合的操作变成同步

SynchromizedBuffer

SynchromizedMap

SynchromizedPriorityQueue

SynchromizedQueue

SynchromizedSet

SynchromizedStack
 
val scores =new scala.collection.collection.mutable.HashMap[String, Int] with scala.collection.mutalbe.SynchronizzedMap[String,Int]

注:这里可以确保scores不会被破坏,任何操作都必须先完成,其他线程才可执行另一个操作。但并发修改和遍历集合并不安全。

通常来说,最好使用java.util.concurrent包中的类.

并行集合 

为了更好利用计算机的多个处理器,支持并发通常是必需的

如果coll是个大型集合,那么

coll.par.sum  //并发求和,par方法产出当前集合的一个并行实现,该实现会尽可能地并行执行集合方法

coll.par.count(_ % 2 ==0) //计算偶数的数量

对数组、缓冲、哈希表、平衡树而言,并行实现会直接重用底层实际集合的实现,所以很高效。

可以通过对要遍历的集合应用.par并行化for循环

for( i <- (0 until 100).par) print( i + " " ) //数字是按照作用于该任务的线程产出的顺序输出

在for/yield循环中,结果是依次组装的

for( i <- (0 until 100).par) yield i +" "

par返回的并行集合扩展自ParSeq ParSet Parmap,都是ParIterable的子类型,不是Iterable的子类型,所以不能将并行集合传递给预期Iterable Seq Set Map的方法。

可以用ser方法将并行集合转换回串行的版本。
只有可以自由结合的操作 可以用平行集合

(a op b) op c = a op( b op c), 加是可自由结合的

(a -b ) -c != a - (b -c)  减法不是自由结合

有一个fold方法对集合的不同部分进行操作,但是不像foldLeft和foldRight那样灵活,

该操作符的两个操作元都必须是集合的元素类型,要求fold的参数类型与集合元素一样,不像上面foldLeft,参数是String, 集合是Int 那样

coll.par.fold(0)(_ + _)

aggregate方法,可以解决上面的问题,该操作符应用于集合的不同部分,然后再用你另一个操作符组合结果

str.par.aggregate(Set[Char]())(_ + _, _ ++ _) //等同于 str.foldLeft(Set[Char]())(_ + _)

产出一个str中所有不同字符的集

 

posted @ 2019-01-17 14:00  大葱拌豆腐  阅读(398)  评论(0编辑  收藏  举报