Scala中的reduceLeft,reduceRight,foldLeft,foldRight方法

雨点打透心脏的1/2处 2022-02-23 07:48 156阅读 0赞

快速代码演示：【只关注reduce和fold从第四点开始看】

object HighLevelFunction extends App {
      val l = List(1, 2, 3, 4, 5)
    
      //1.map 逐个操作集合里面的每个元素
      l.map((x: Int) => x + 1) //将List内的每个元素(x:Int) + 1
      l.map(x => x + 1)        //scala能帮我们推断出List内每个元素是Int,且只有一个元素时候,括号可以省略
      l.map(_ + 1)             //对List中的任意元素都 + 1
      //遍历
      l.map(_ + 1).foreach(print)    //23456 List[Int]
    
      println()
      println("-------------")
    
      //2.在map取出每个元素 + 1的基础上,使用filter过滤出 < 4的数字
      l.map(_ + 1).filter(_ < 4).foreach(print)   //23  List[Int]
    
      println()
      println("-------------")
    
      //3.使用take取集合中的前3个元素
      l.take(3).foreach(print)      //123    List[Int]
    
      println()
      println("-------------")
    
      //4.reduce
      print(  l.reduce(_ + _)  )  //15     Int  将l集合中的前后元素两两相加 1+2 3+3 6+4 10+5
    
      println()
      println("-------------")
    
      //5.reduceLeft = reduce
      print(  l.reduceLeft(_ - _)  )   //-13  1 - 2 - 3 - 4 - 5 = -13
    
      println()
      println("-------------")
    
      //6.reduceRight
      print(  l.reduceRight(_ - _)  )  //3   （ 1 - ( 2 - ( 3 - ( 4 - 5 ））））
    
      println()
      println("-------------")
    
      //7.fold(第一个括号代表初始值)
      print(  l.fold(0)(_ - _)  )    //-15  0-1-2-3-4-5 = -15
    
      println()
      println("-------------")
    
      //8.foldLeft = fold  (0在最左边)
      print(  l.foldLeft(0)(_ - _))  //-15  0-1-2-3-4-5 = -15
    
      println()
      println("-------------")
    
      //9.foldRight        (0在最右边)
      print(  l.foldRight(0)(_ - _) ) //3    ( 1 - ( 2 - ( 3 - ( 4 - (5 - 0) ) ) ) )
    }

scala中集合类iterator特质的化简和折叠方法   
**c.reduceLeft(op)**这样的调用将op相继应用到元素，如：   
![这里写图片描述][SouthEast]

eg:

val a = List(1,7,2,9)
    val a1 = a.reduceLeft(_ - _)//      ((1-7) - 2) - 9 = -17

**c.reduceRight(op)**这样的调用将op相继应用到元素，如：

var b = List(1,2,3,4,5)
    val c = b.reduceRight(_ - _)    // （ 1 - ( 2 - ( 3 - ( 4 - 5 ) ) ) )

**c.foldLeft(0)(\_ \* \_)方法 **

val a2 = a.foldLeft(0)(_ - _)     //    0-1-7-2-9 = -19

对于foldLeft方法还有一种简写，这种写法的本意是让你通过/:来联想一棵树的样子   
对/:操作符来说，初始值是第一个操作元本题中是0，：后是第二个操作元a

val a3 = (0 /: a)(_ - _) //      等价于a.foldLeft(0)(_ - _)

scala同样也提供了**foldRight或:\\**的变体，计算

val a4 = a.foldRight(0)(_ - _)//    1-(7-(2-(9-0))) = -13
    val a5 = (a :\ 0)(_ - _)   //    等价于a.foldRight(0)(_ - _)

好像上面的方法都没什么用，但折叠fold有时候可以代替循环，例如：   
统计每个字母中字符串出现的次数

val frep  = collection.mutable.Map[Char,Int]() //   使用可变集合
    //      使用for循环来统计次数
        for(c <- "Mississippi") frep(c) = frep.getOrElse(c, 0)+1
    //      使用/: foldLeft()()来统计次数
        val result = (Map[Char,Int]() /: "Mississippi"){
            (m,c) => m + (c -> (m.getOrElse(c, 0)+1))
        }
    //      任何while循环都可用fold来代替
        println(frep,result) //(Map(M -> 1, s -> 4, p -> 2, i -> 4),Map(M -> 1, i -> 4, s -> 4, p -> 2))

这是使用fold的步骤：在每一步，将频率映射和新遇到的字母结合在一起，产生一个新的频率映射。这就是折叠：   
   
fold的初始值和操作符是分开定义的柯里化参数，这样scala就可以呀根据类型来推断操作符的类型定义。   
eg:该函数的初始值是String，因此操作符的类型应该是(String,Int) => String的函数

val a7 = a.foldLeft("")(_ + _)
    val a8 = a.foldRight("")(_+_)
    val a9 = a.fold(0)(_+_)
    println(a7,a8,a9) //    (1729,1729,19)

[SouthEast]: /images/20220223/1d584c1cd581419aad60ab79b9d7979e.png