Spark行动操作Action

 1.定义:触发Job,调用runJob()方法:
       比如:collect、count
    2.foreach
       说明:将结果返回值执行器节点,而非驱动器(collect),
    3.aggregate
       def aggregate[U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U
       说明:aggregate用于聚合RDD中的元素,先使用seqOp将RDD中每个分区中的T类型元素聚合成U类型,
             再使用combOp将之前每个分区聚合后的U类型聚合成U类型
         特别注意seqOp和combOp都会使用zeroValue的值,zeroValue的类型为U
        val z = sc.parallelize(List(1,2,3,4,5,6), 2)
    z.aggregate(0)(math.max(_, _), _ + _)
    res40: Int = 9
        说明:
        step1:首先在第一个分区[0,1,2,3]中执行math.max,结果为:3
            step2:在第二个分区[0,4,5,6]中执行math.max,结果为:6
        stepn:在第N个分区中执行math.max,结果为:max
            step:将所有分区结果执行combOp(_+_),0+3+6=9
    z.aggregate(5)(math.max(_, _), _ + _)
    res29: Int = 16
    说明:
        // This example returns 16 since the initial value is 5
        // reduce of partition 0 will be max(5, 1, 2, 3) = 5
        // reduce of partition 1 will be max(5, 4, 5, 6) = 6
        // final reduce across partitions will be 5 + 5 + 6 = 16
        // note the final reduce include the initial value
    
    案例说明:
    scala> val z = sc.parallelize(List("12","23","345","4567"),2)
    z: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[3] at parallelize at <console>:24

    scala> z.glom.collect
    res11: Array[Array[String]] = Array(Array(12, 23), Array(345, 4567))

    scala> z.aggregate("")((x,y) => math.max(x.length, y.length).toString, (x,y) => x + y)
    res12: String = 42

    scala> z.aggregate("")((x,y) => math.max(x.length, y.length).toString, (x,y) => x + y)
    res13: String = 24
        说明:
         step1:第一个分区中执行math.max(x.length, y.length).toString代码
                    res0=:math.max(“”.length, “12”.length).toString = “2”
            res1=:math.max(res0.length, “23”.length).toString = “2”
            第一个分区最终返回值为:2
         step2:第二个分区中执行math.max(x.length, y.length).toString代码
                    res2=:math.max(“”.length, “345”.length).toString = “3”
            res3=:math.max(res2.length, “4567”.length).toString = “4”
            第一个分区最终返回值为:4
         step3:最后执行(x,y) => x + y   :24  或  42
    scala> z.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)
    res14: String = 11
             step1:第一个分区中执行math.min(x.length, y.length).toString代码
                    res0=:math.min(“”.length, “12”.length).toString = “0”
            res1=:math.min(res0.length, “23”.length).toString = “1”
            第一个分区最终返回值为:1
         step2:第二个分区中执行math.min(x.length, y.length).toString代码
                    res2=:math.min(“”.length, “345”.length).toString = “0”
            res3=:math.min(res2.length, “4567”.length).toString = “1”
            第一个分区最终返回值为:1
         step3:最后执行(x,y) => x + y   :11  或 11
    scala> z.aggregate("12")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)
    res15: String = 1211
             step1:第一个分区中执行math.min(x.length, y.length).toString代码
                    res0=:math.min(“12”.length, “12”.length).toString = “2”
            res1=:math.min(res0.length, “23”.length).toString = “1”
            第一个分区最终返回值为:1
         step2:第二个分区中执行math.min(x.length, y.length).toString代码
                    res2=:math.min(“12”.length, “345”.length).toString = “2”
            res3=:math.min(res2.length, “4567”.length).toString = “1”
            第一个分区最终返回值为:1
         step3:最后执行(x,y) => x + y   :1211  或 1211
    4.fold
        def fold(zeroValue: T)(op: (T, T) => T): T
        说明:fold理解为aggregate的简化
     val a = sc.parallelize(List(1,2,3), 3)
     a.fold(0)(_ + _)
     res59: Int = 6


惰性求值
--------------------------------
    1.定义:
         在RDD行动操作之前,不触发计算。转换操作和创建操作、控制操作均为惰性的;
         只有行动操作可触发Job。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值