spark之action算子

first() count() reduce()

    @Test
    def test3(): Unit ={

        val rdd1: RDD[(String, Int)] = sc.makeRDD(Array(("A",1),("B",2),("C",3)))

        println(rdd1.first()) //返回第一个元素 ("A",1)
        println(rdd1.count()) //返回元素个数 3

        val rdd2: RDD[Int] = sc.makeRDD(1 to 10,2 )
        val i: Int = rdd2.reduce(_ + _) //作用于每个元素 这里求和 55
        println(i)
    }

aggregate

    /**
      * def aggregate[U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U)
      * 1 to 6 两个分区 分别是 (1,2,3)    (4,5,6)
      *
      * seqOp 将RDD中每个分区中的T 类型元素聚合成U类型 再使用combOp将之前的每个分区聚合后的U类型 聚合成U类型,特别注意的是seqOp和comOp都会使用zeroValue的之
      * 分区一中zeroValue+1+2+3   = 1+1+2+3 = 7
      * 分区二中zeroValue+4+5+6   = 1+4+5+6 = 16
      * 再将分区中的结果合并(comOp) zeroValue+1+分区1中聚合的之+分区2中聚合的值 = 1 + 7 + 16 = 24
      */
    @Test
    def test4(): Unit ={
        val rdd1: RDD[Int] = sc.makeRDD(1 to 6,2)

        val i: Int = rdd1.aggregate(1)(
            { (x: Int, y: Int) => x + y }, { (a: Int, b: Int) => a + b }
        )
        println(i)
               //和aggregate的结果一样
        val i1: Int = rdd1.fold(1)((x, y) => x+y)
        println(i1)
    }

foreachPartition

    /**
      * foreachPartition和foreach类似,对每一个分区使用f
      * 打印值为 6 和 16每个分区中的总和
      */
    @Test
    def test6(): Unit ={
        val rdd1: RDD[Int] = sc.makeRDD(1 to 6,2)

        rdd1.foreachPartition((iter:Iterator[Int])=>{
            var i = 0
            while (iter.hasNext){
                val i1: Int = iter.next()
                i  += i1
            }
            println(i)
        })
    }
}