精华内容
下载资源
问答
  • scala foldLeft foldRight

    2020-08-25 00:10:56
    聊一聊scala的foldLeft方法和foldRight方法。

    今天在熟悉项目代码的时候,看到了代码中用到了foldLeft方法,说来惭愧,用scala写了一年spark都没有用到这个方法,太菜了。

    以下均个人理解,可能不是很对,欢迎交流。


    概念

    从字面意思上看,fold是折叠,那么foldLeft应该是向左折叠,foldRight应该是向右折叠。

    在scala中亦是如此。

    在这里插入图片描述

    先以foldLeft为例,泛型为B,第一个参数是B类型的值,第二个参数是一个返回值为B类型值的函数,返回值是B类型的值。

    看看foldLeft中作为参数传入的函数(op: (B, A) => B),这个函数第一个参数是B类型,第二个参数是A类型,返回值是B类型。

    foldLeft的第一个参数,会作为第二个参数所传入函数的B类型参数的默认值。

    所以foldLeft其实就是把右边的A类型值向左折叠到左边的B类型值上,并返回作为下一轮的左侧。遍历完成后返回。


    再看看foldRight,也是以第一个参数作为B类型的初始值,之后在第二个参数的函数中把左边的A右折叠到右边的B上,并返回作为下一轮的右侧。

    需要注意的是,foldRight会先将集合翻转。

    demo

    foldLeft Demo

    val list = List(1, 2, 3, 4, 5)
    val res1 = list.foldLeft(0)((a, b) => {
    	a-b
    })
    println(res1)
    

    res1的值是-15。

    过程如下:0作为a的初始值,向左折叠

    a		b		 运算	 
    0   	1		0-1=-1
    -1  	2		-1-2=-3
    -3  	3		-3-3=-6
    -6  	4		-6-4=-10
    -10 	5		-10-5=-15
    -15
    

    foldRight Demo

    val list = List(1, 2, 3, 4, 5)
    val res2 = list.foldRight(0)((a, b) => {
    	a-b
    })
    println(res2)
    

    res2的值是3。

    过程如下:0作为b的初始值,翻转列表,向右折叠

    a		b          运算        
    1		0         1-0=1
    2		1         2-1=1      
    3		1         3-1=2    
    4		2		  4-2=2
    5		2         5-2=3
    		3
    

    总结

    def foldLeft[B](z: B)(op: (B, A) => B): B
    def foldRight[B](z: B)(op: (A, B) => B): B 
    

    根据参数类型来区分较为清晰,好理解。

    foldLeft:z作为B类型初始值,之后将右边的A类型折叠到左边B类型,循环计算,返回左边B类型。

    foldRight:先翻转集合,将z作为B类型初始值,之后将左边的A类型折叠到右边B类型,循环计算,返回右边B类型。


    个人理解,欢迎交流。

    展开全文
  • Scala的foldLeft和foldRight

    千次阅读 2018-05-19 09:22:05
    点进去发现, /:实际是foldLeft操作 def /:[B](z: B)(op: (B, A) => B): B = foldLeft(z)(op) def foldLeft[B](z: B)(op: (B, A) => B): B = { var result = z this.seq foreach...

    首先看一个例子, 发现 /:不知道是什么
    这里写图片描述

    点进去发现, /:实际是foldLeft操作

      def /:[B](z: B)(op: (B, A) => B): B = foldLeft(z)(op)
    
      def foldLeft[B](z: B)(op: (B, A) => B): B = {
        var result = z
        this.seq foreach (x => result = op(result, x))
        result
      }

    首先来看下 foldLeft

      def foldLeft[B](z: B)(op: (B, A) => B): B = {
        var result = z
        this.seq foreach (x => result = op(result, x))
        result
      }

    方法接收两个参数, z和op, 一个是B类型的参数z, 另一个是返回B类型的**函数**op
    在看到这个trait其实是TraversableOnce,可迭代的集合。
    def seq: TraversableOnce[A]

    比如一个val listA = List(1,2,3)
    listA其实是实现了TraversableOnce这个trait的。
    我们可以直接使用:

    object TestFoldLeft {
        def main(args: Array[String]): Unit = {
          val listA = List(1, 2, 3)
          val b = (10/:listA)(_+_)
          val c = listA.foldLeft(10)(_+_)
          println(b)
        } 
    }

    这个里面的10其实就是z返回值是Int类型即B类型
    那么可以看出op这个函数返回值也需要是Int类型

    可以看出

    val result = z, 这里其实就是10,x=>result=op(result, x) ,

    其实z就是返回值,this.seq在这里就是list,对list遍历,这里执行op函数。

    这里我们执行的是_+_,就是累加了10+1+2+3=16

    展开全文
  • fold, foldLeft, and foldRight之间的区别  主要的区别是fold函数操作遍历问题集合的顺序。foldLeft是从左开始计算,然后往右遍历。foldRight是从右开始算,然后往左遍历。而fold遍历的顺序没有特殊的次序。 case...

    fold, foldLeft, and foldRight之间的区别
      主要的区别是fold函数操作遍历问题集合的顺序。foldLeft是从左开始计算,然后往右遍历。foldRight是从右开始算,然后往左遍历。而fold遍历的顺序没有特殊的次序。 

    case class Foo(val name: String, val age: String, val sex: String)
    
    Object Test{
    
    def main(args:Array[String]){
    val array = ArrayBuffer[Foo]()
        array.append(Foo("Hugh Jass", "25", "male"))
        array.append(Foo("Biggus Dickus", "43", "male"))
        val stringList = array.foldLeft(List[String]()) { (z, f) =>
          val title = f.sex match {
            case  "male" => "Mr."
            case  "female" => "Ms."
          }
          z :+ s"$title ${f.name}, ${f.age}"
        }
    
    
        println("stringList:" + stringList(0))
    }
    }

     

     

    //伴生类 
    class Foo(val name: String, val age: Int, val sex: Symbol)
    
     //伴生对象
    object Foo {
      def apply(name: String, age: Int, sex: Symbol) = new Foo(name, age, sex)
    } 
    
    Object Test{
    
    def main(args:Array[String]){
     
      val fooList =
          Foo("Hugh Jass", 25, 'male) ::
            Foo("Biggus Dickus", 43, 'male) ::
            Foo("Incontinentia Buttocks", 37, 'female) ::
            Nil
    
    
        val stringList1 = fooList.foldRight(List[String]()) { (z, f) =>
          val title = z.sex match {
            case 'male => "Mr."
            case 'female => "Ms."
          }
          f :+ s"$title ${z.name}, ${z.age}"
        }
    
        println("stringList1:" + stringList1(0))
    
    }
    }

     

    展开全文
  • Scala中foldLeft的简单使用总结_Scala中foldLeft的简单使用总结-CSDN博客 Scala中foldLeft的简单使用总结 由于工作需要,博主在写spark相关业务代码时用到foldLeft,经过一番搜寻发现很多文章对这个函数的讲解,于...

    原地址:

    Scala中foldLeft的简单使用总结_Scala中foldLeft的简单使用总结-CSDN博客

    Scala中foldLeft的简单使用总结
    由于工作需要,博主在写spark相关业务代码时用到foldLeft,经过一番搜寻发现很多文章对这个函数的讲解,于初学者来说不好理解,特此我来做个简单易懂的分析总结,供大家参考。
    若发现理解上的偏差,还请多指教。

    源码分析
    def seq: TraversableOnce[A]

    scala.collection.TraversableOnce
    上面两段代码是scala.collection.TraversableOnce特质的foldLeft方法源代码,实现了TraversableOnce trait的seq就是可迭代的集合;

     

        //将初始值z赋给result变量
        var result = z
        //遍历seq集合,将result变量与seq集合取出的每个对象作为参数传递给op函数,每迭代一次op函数的返回值都赋给result变量
        this.seq foreach (x => result = op(result, x))  
        //最终获取result作为返回值
        result

    示例
        val lst = List(20,30,60,90)
        //0为初始值,b表示返回结果对象(迭代值),a表示lst集合中的每个值
        val rs = lst.foldLeft(0)((b,a)=>{
          b+a
        })

    运行过程为:b=0+a,即0+20=20
    b=20+a,即20+30=50
    b=50+a,即50+60=110
    b=110+a,即110+90=200
    此处的a为循环取出集合中的值
    最终结果: rs=200

    展开全文
  • fold、foldLeft、foldRight是scala常用的列表规约操作,最终实现的效果也差不多,但他们的区别在哪里呢?发现网上文章很多,能讲清楚的很少。 问题描述 三个函数都是给定一个起始值和一个规约函数对列表进行规约,...
  • Scala List foldLeft用法

    千次阅读 2015-03-13 18:48:09
    def sum(list: List[Int]): Int = list.foldLeft(0)((r,c) => r+c) def sum(list: List[Int]): Int = list.foldLeft(0)(_+_)def product(list: List[Int]): Int = list.foldLeft(1)(_*_)def count(list: List[Any]):
  • 一、reduceLeft和foldLeft的基本解释 reduceLeft表达式: foldLeft表达式: 二、reduceLeft和foldLeft的实例应用 三、Range 定义Range 生成Range 四、Stream 定义Stream 生成Stream 访问Stream元素 一...
  • Scala中foldLeft的总结

    2019-03-30 13:41:00
    上面两段代码是scala.collection.TraversableOnce特质的foldLeft方法源代码,实现了TraversableOnce trait的seq就是可迭代的集合; //将初始值z赋给result变量 var result = z //遍历seq集合,将result变量与...
  • Scala: foldLeft和foldRight 实战

    千次阅读 2015-07-25 20:32:18
    Scala: foldLeft和foldRight 实战 scala源代码: def /:[B](z: B)(op: (B, A) => B): B = foldLeft(z)(op) def :\[B](z: B)(op: (A, B) => B): B = foldRight(z)(op) 在scala命令行运行 scala> (0/:(1 to 100))...
  • scala中的foldLeft学习

    2019-02-26 21:40:16
    闲来无事,在stackoverflow上看代码玩,偶尔发现一个之前没有用过的函数--foldLeft函数。现做记录如下: val sourceDF = Seq( (" p a b l o", "Paraguay"), ("Neymar", "B r...
  • HOF foldLeft / foldRight foldLeft 和 foldRight 都是对于 List 遍历的 高阶函数。是对列表遍历过程中进行函数操作的高阶函数抽象。 List 遍历 假设有两个方法如下 // 求和 def sum(ints: List[Int]): ...
  • scala之foldLeft和foldRight

    2019-05-15 16:29:43
    foldLeft /: 结果都等于-15,运算过程((((0-1)-2)-3)-4)-5 (0/:(1 to 5))(_-_) (0/:(1 to 5))((k,i) => k-i) (0/:(1 to 5))((i,k) => i-k) 上面3行与下面的foldRight两个结果相等 ((1 to 5):\0)...
  • Scala的foldLeft和foldRight1.foldLeft和foldRight1.foldLeft定义:def foldLeft[B](z:B)(f:(B, A) => B): B={ var acc = z var these = this while (!these.isEmpty) { acc = f(acc, these.head)
  • 首先来看一下foldLeft: def foldLeft[B](z: B)(op: (B, A) => B): B = { var result = z this foreach (x => result = op(result, x)) result }
  • http://blog.csdn.net/oopsoom/article/details/23447317 def/:[B](z:B)(op:(B,A)=>B):B=foldLeft(z)(op) def:\[B](z:B)(op:(A,B)=>B):B=foldRight(z)(op) 转载于:https://www.c...
  • scala里面的foldLeft和foldRight

    千次阅读 2013-09-12 15:46:13
    直接上代码 foldLeft: 结果: foldRight: 结果: 总结:
  • foldLeft: 比如 List(1,7,2,9).foldLeft(0)(_-_) 其中0是初始值 一般情况下对于foldLeft可以这么解决:0-1-7-2-9 = -19 还可以画一个图(别吐槽): 本栗子的操作就是_-_,也就是各元素相减,所以我们从底端开始就...
  • 代码:结果:/:是foldLeft的缩写,:\是foldRight的缩写a/:b 结果得是b
  • fold, foldLeft和foldRight这三个函数做的事情差不多仅有一点点不同。下文解释它们的共同点并解释它们的不同点。  举一个简单的例子,用fold计算一系列整型的和。 valnumbers=List(5,4,8,6,2) numbers....
  • scala foldLeft & foldRight

    2011-06-24 12:55:39
    foldLeft /: ([color=red][b]s[/b][/color])(s,t=>) foldRight :\ ([color=red][b]t[/b][/color])(s,t=>) 这里的s,t的变换很巧妙,也可以说很讨厌,下面两列对应与(s,t) [quote] [b][size=large]另外一...
  • 这是左折叠的一个典型例子,List(1,2,3) 是我们的操作主体 foldLeft是方法 0 是操作结果集(个人理解),这里的0是指初始值为0 后面是(sum,i)=>sum+i 是操作函数,我们可以用任意合乎语法规则的函数来替换它,...
  • fold/foldLeft/foldRight区别和联系

    千次阅读 2016-05-01 09:59:30
    fold, foldLeft和foldRight这三个函数除了有一点点不同外,做的事情差不多。我将在下文解释它们的共同点并解释它们的不同点。 我将从一个简单的例子开始,用fold计算一系列整型的和。val numbers = List(5, 4, 8, 6...
  • Scala的foldLeft,reduceLeft,foldRight,reduceRight,reduce之间的区别——就在于......
  • fold, foldLeft和foldRight这三个函数除了有一点点不同外,做的事情差不多。我将在下文解释它们的共同点并解释它们的不同点。  我将从一个简单的例子开始,用fold计算一系列整型的和。 val ...
  • 1.先了解一点,reduce与fold原理相同,只不过fold有初值,reduce直接使用集合中的元素,同理reduceLeft,reduceRight和foldLeft,foldRight也一样 2.reduce与reduceLeft功能与原理都一样,两者选其一即可;fold与...
  • def main(args: Array[String]): Unit = { println((1 to 100).foldLeft(0)(_ + _)) //初始值为0,从1一直加到100 println(( 0 /: (1 to 100) ) (_ + _)) println((1 to 5).foldRight(100) (_ - _)) //初始值为

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,035
精华内容 1,214
关键字:

foldleft