手机版 欢迎访问it开发者社区(www.mfbz.cn)网站

当前位置: > 开发

读scala的reduce、Flod函数源码笔记

时间:2021/6/3 23:00:24|来源:|点击: 次

记录一下,怕以后忘记,有些还没有看懂,不懂的先猜以及跑例子,之后再补。

 

目录

准备

reduce

reduceLeft

reduce

reduceRight

Flod

未完待续 


准备

关于类型,在控制台运行可以方便观察到类型

val one = 1    // 输出:one: Int = 1, 类型:Int

val list = List(1, 2) // 输出:list: List[Int] = List(1, 2),类型List[Int],中括号里的是范型

val g = (x: Int) => x *3 // 输出:g: Int => Int = <function1>, 对照上面,则类型: Int => Int ,亦可以稍微补全,val g: Int => Int = (x: Int) => x * 3 

    表示输入Int,输出Int

val product = (x: Int, y: Int) => x * y // 输出:product: (Int, Int) => Int = <function2>,类型:(Int, Int) => Int,稍微补全一下,val product: (Int, Int) => Int = (x: Int, y: Int) => x * y

    表示输入有两个参数,类型分别Int和Int,输出是Int类型

reduce

总结:就想一下数学运算的结合律,我们将序列中所有的元素,看成二元运算的两个操作数,由于是相同的运算,可以不考虑优先级;

那么就剩左右结合,reduce和reduceLeft是左结合,看成()从左往右依次括起来,即从左往右算;

reduceRight是右结合,看成()从右往左依次括起来,即从右往左算。

reduceLeft

reduceLeft,源码如下

def reduceLeft[B >: A](op: (B, A) => B): B = {
    if (isEmpty)
      throw new UnsupportedOperationException("empty.reduceLeft")

    var first = true
    var acc: B = 0.asInstanceOf[B]

    for (x <- self) {
      if (first) {
        acc = x
        first = false
      }
      else acc = op(acc, x)
    }
    acc
  }

函数名:reduceLeft,范型[B >: A]

入参op,op的类型是(B,A) => B,参照前面的类型,可以理解为,op是一个函数,接受两个参数,类型分别为B和A,返回类型是B

reduceLeft的整个函数的返回类型也是B。

依据隐式转换以及网上资料搜索,B >: A,表示类型B是类型A的父类(也可以是A)。

self:暂时不知道是啥,目测是代表这个序列

  1. 若序列为空,抛异常
  2. 定义B类型的acc用来记录结果,默认值是0转换成B类型的值。
  3. 对序列中的每一个元素进行操作
    1. 若是序列的第一个值,将其赋给acc
    2. 序列中的其余的值,都需要将op这个函数作用于(acc, 序列中的元素)并返回acc

举例:

    val list = List(1, 2, 3), list.reduceLeft(_ - _)

    1. acc = 0.asInstanceOf[Int],则acc = 0

    2. 遍历下标为0的1,则acc = 1

    3. 遍历下标为1的2, 则acc = acc - 2 = -1

    4. 遍历下标为2的3, 则acc = acc - 3 = -4

    5. 将acc作为结果返回,即-4

简而言之,结果=(1 - 2) - 3 = -4,从左往右,先有(1-2),再有(1-2)-3

scala> val list = List(1, 2, 3)  // list: List[Int] = List(1, 2, 3)

scala> list.reduce(_ - _)       //res120: Int = -4

scala> l                                 // List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8)

scala> l.reduceLeft(_ - _)     // res150: Int = -34

可以看成:先有1 - 2, 再有(1 - 2) - 3, 再( (1 - 2) - 3) - 4,即(((((( (1 - 2) - 3) - 4) - 5) - 6) -7) - 8) = -34

reduce

reduce,源码如下

def reduce[A1 >: A](op: (A1, A1) => A1): A1 = reduceLeft(op)

直接调用的reduceLeft函数,所以结果同上,

scala> list                           // res127: List[Int] = List(1, 2, 3)

scala> list.reduce(_ - _)      // res126: Int = -4

reduceRight

reduceRight,源码如下

def reduceRight[B >: A](op: (A, B) => B): B = {
    if (isEmpty)
      throw new UnsupportedOperationException("empty.reduceRight")
    // 这边注意一下顺序,(x, y) => op(y, x)
    reversed.reduceLeft[B]((x, y) => op(y, x))
}

override /*TraversableLike*/
def reduceLeft[B >: A](f: (B, A) => B): B =
    if (isEmpty) throw new UnsupportedOperationException("empty.reduceLeft")
    else tail.foldLeft[B](head)(f)

// currying函数
override /*TraversableLike*/
def foldLeft[B](z: B)(@deprecatedName('f) op: (B, A) => B): B = {
    var acc = z
    var these = this
    while (!these.isEmpty) {
      acc = op(acc, these.head)
      these = these.tail
    }
    acc
}

其实就是一句话: reversed.reduceLeft[B]((x, y) => op(y, x)),我们先来看看reversed

reversed,源码如下

protected[this] def reversed = {
    var elems: List[A] = Nil
    self foreach (elems ::= _)
    elems
  }

这个reversed,生成翻转的序列,我们瞄一下

scala> l                                   // List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8)

scala> var nil: List[Int] = Nil    // reversedL: List[Int] = List()

scala> l foreach (nil::= _)        // 

scala> reversedL                    // res136: List[Int] = List(8, 7, 6, 5, 4, 3, 2, 1)

再来看这一句话,reversed.reduceLeft[B]((x, y) => op(y, x))

与reduce也即reduceLeft的区别:1.在反转序列的基础上做的;2.调用的是LinearSeqOptimized类的foldLeft函数。

  1. 反转序列,设反转后的序列为reversedL
  2. acc = reversedL.head, these= reversedL.tail
    1. acc = op(these.head, acc), these=these.tail,循环

举例:

    val list = List(1, 2, 3), list.reduceRight(_ - _)

     A. 生成临时反转序列,reversedL, (3, 2, 1)

    1. acc = 3,these=(2,1)

    2. these不为空, acc= these.head - acc= 2 - 3 = -1, these = (1,)

    3. these不为空, acc= these.head - acc= 1 - (-1) = 2, these = ()

    4. theae为空,退出循环,结果返回,即2

简而言之,结果= 1 - (2 - 3) = 2,这边看成从右往左写,即先有2 - 3的结果,再有1 - (2 - 3)

scala> val list = List(1, 2, 3)  // list: List[Int] = List(1, 2, 3)

scala> list.reduce(_ - _)       //res120: Int = 2

scala> l                                 // List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8)

scala> l.reduceLeft(_ - _)     // res150: Int = -4

可以看成:先有(7 - 8),再有6 - (7 - 8), 再有5 - (6 -( 7- 8)), 即 (1-(2-(3-(4-(5-(6-(7-8))))))) = - 4,

Flod

未完待续 

Copyright © 2002-2019 某某自媒体运营 版权所有