SCALA-集合与函数式编程（二）

一、集合元素的映射&筛选

1.1map

//将集合中的每一个元素通过指定功能（函数）映射（转换）成新的结果集合，这里其实就是所谓的将函数作为参数传递给另外一个函数,这是函数式编程的特点

//相当于让一个集合中的元素，依次作为参数传递给某个方法，然后返回一个结果集。

def main(args: Array[String]): Unit = {   val names=List("Alice","Bob","Nick")   def upper(s:String): String ={     s.toUpperCase()   }   val results = names.map(upper) //直接传入方法   println("results:"+results) }

1.2flatmap

//flat即压扁，压平，扁平化，效果就是将集合中的每个元素的子元素映射到某个函数并返回新的集合

val charactors=List("郭靖","洪七公","欧阳锋") def getFamily(name:String) :List[String]={       if(name=="郭靖"){         return List("郭靖","黄蓉","郭襄")       }else{          return List(name)       } }  println("faltmap:"+ charactors.flatMap(getFamily))

1.3filter

//将符合要求的数据(筛选)放置到新的集合中

val names = List("Alice", "Bob", "Nick") def findA( s : String ) : Boolean = {  //函数必须返回值是布尔型     s. startWith("A") } println(names.filter(find))  //所有返回true的才被打印

二、化简、折叠、扫描

2.1折叠，化简（reduce）

//将二元函数引用于集合中的函数

val list = List(1, 2, 3, 4, 5)   def minus( num1 : Int, num2 : Int ) : Int = {     num1 - num2   }   val i1 = list.reduceLeft(minus)//从左边减少，从右边减少   val i2 = list.reduceRight(minus)

2.2折叠，化简（fold）

//将上一步返回的值作为函数的第一个参数继续传递参与运算，直到list中的所有元素被遍历

val list2 = List(1, 9, 2, 8) def minus( num1 : Int, num2 : Int ) : Int = { num1 - num2 } val i4 = list2.fold(5)(minus) val i5 = list3.foldRight(100)(minus)//(list4:\0)(minus) val i6 = list3.foldLeft(100)(minus)//(0 /: list4)(minus)

2.3使用映射集合，统计一句话中，各个文字出现的次数,存放到集合中 Map[Char, Int]()

val array = sentence.toCharArray val map = new scala.collection.mutable.HashMap[Char, Int] //空映射 def sentenceCount(str1: Char, str2: Char): Char = { if (!map.contains(str2)) map.put(str2, 1) else { map.put(str2, map(str2) + 1) } return str2 } array.fold('A')(sentenceCount)

val s = sentence.toCharArray.map((_, 1)).groupBy(_._1).map(t => (t._1, t._2.size))

val s = (Map[Char, Int]() /: sentence) ((m, c) => m + (c -> (m.getOrElse(c, 0) + 1)))

2.4折叠，化简，扫描（scanLeft()()，scanReight()()）

//即对某个集合的所有元素做fold操作，但是会把产生的所有中间结果放置于一个集合中保存。

def minus( num1 : Int, num2 : Int ) : Int = { num1 - num2 } val i8 = (1 to 5).scanLeft(0)(minus)

三、拉链（交叉合并）

val boys=List("令狐冲","段誉","杨过" )  val girls = List("任盈盈","王语嫣","小龙女") //List((令狐冲,任盈盈), (段誉,王语嫣), (杨过,小龙女))

四、流

//stream是一个集合。这个集合，可以用于存放，无穷多个元素，但是这无穷个元素并不会一次性生产出来，而是需要用到多大的区间，就会动态的生产，末尾元素遵循lazy规则。（要使用结果才进行计算的）

4.1流的创建及基本操作

//流Stream，使用#::得到一个stream def numsForm(n: BigInt): Stream[BigInt] = n #:: numsForm(n + 1) //传递一个值，并打印stream集合 val stream = numsForm(10) println(s"stream = ${stream}") //tail的每一次使用，都会动态的向stream集合按照规则生成新的元素 println(s"stream = ${stream.tail}") println(s"stream = ${stream}")

4.2从0-100000的随机数中，挑选可以被10整除的n个数

def nums(): Stream[Int] = { Random.nextInt(10000) #:: nums() } val list = nums().filter(_ % 10 == 0).take(5).toList

五、视图

//Stream的懒加载特性，也可以对其他集合应用view方法来得到类似的效果，该方法产出一个其方法总是被懒执行的集合。但是view不会缓存数据，每次都要重新计算。

5.1找到100以内，所有数字倒序排列还是它本身的数字

def views(int: Int): Boolean = { int.toString == int.toString.reverse } val unit = (1 to 100).view.filter(views).take(15) unit.foreach(n => { println(n) })

六、并行集合

//Scala为了充分使用多核CPU，提供了并行集合（有别于前面的串行集合），用于多核环境的并行计算。

• Divide and conquer : 分治算法，Scala通过splitters，combiners等抽象层来实现，主要原理是将计算工作分解很多任务，分发给一些处理器去完成，并将它们处理结果合并返回
• Work stealin：算法，主要用于任务调度负载均衡（load-balancing），通俗点完成自己的所有任务之后，发现其他人还有活没干完，主动（或被安排）帮他人一起干，这样达到尽早干完的目的。

(1 to 5).foreach(println(_)) println() (1 to 5).par.foreach(println(_))