SparkCore之RDD算子Action

  /**
    * 1、collect
    * 1）返回 Array(ele)
    * 2）实现方法：遍历添加到数组
    * 3）需要注意的是因为该方法是把所有的数据放到内存，所以不适合大量数据==>否则OOM
    *
    * 2、take
    * 前n个元素
    * collect vs take =====>
    * collect 是直接计算所有结果，把每个partition的结果变成array，再合并成一个array
    * take 会先计算1个partition，然后根据结果的的数量推断还需要计算几个分区，计算这几个分区
    * 看结果够不够，不够再迭代。
    *
    * 3、count：返回元素个数
    * 4、first：返回第一个元素，调用take(1)
    * 5、top：
    * 返回largest的前n个元素
    * 底层调用Ordering排序
    * OOM
    * 6、takeOrdered：返回最小的前n个元素
    * 7、reduce 两两操作
    * 8、foreach、foreachPartition 遍历
    * 9、countByKey
    * 统计key，用于数据倾斜统计key的数量
    * 实现：mapValues(_=>1L).reduceByKey(_+_).collect
    * 10、countByValue：统计相同元素的个数
    * 看名字还以为是对KV类型RDD按Value统计
    * 实际测试，是统计相同元素个数
    * List(("a",1),("b",2),("c",1))==countByValue==>Map(("a",1)->1,("b",2)->1,("c",1)->1)
    * 我们再看下源码： 调用的是 RDD下的map(value => (value, null)).countByKey()
    * 从源码来看
    * 1）RDD说明不仅仅只能用于PairRDD
    * 2) map(value=>(value,null))确实是对整个元素操作
    * 3) 如果按我们想的应该是调用PairRDD,实现map(value => (value._2, 1L)).countByKey()
    *
    * @param sc
    */
  def actionTest(sc: SparkContext): Unit = {
    val rdd = sc.parallelize(List(1, 2, 3))

    //返回包含所有元素的Array
    rdd.collect()
    //前n个元素
    rdd.take(2)
    //元素个数
    //实现遍历累加计数器
    rdd.count()
    //第一个元素，调用take(1)
    rdd.first()
    //返回最大的(largest 排序)前n个元素，底层有调用
    //放到内存，适合小数据==>oom
    rdd.top(-1)
    rdd.top(1)(Ordering.by(x => -x)) //针对数值类型，升序方式
    //返回小的，升序
    rdd.takeOrdered(2)
    //两两相加
    rdd.reduce(_ + _)
    rdd.foreach(println(_)) //遍历元素
    rdd.foreachPartition(partition => { //遍历分区
      partition.foreach(println(_))
    })
    rdd.countByValue() // map(v=>(v,null)).countByKey
    rdd.map((_, 2)).countByKey() // mapValues(x=>1L).reduceByKey(_+_).collect
    //rdd.map((_,1)).mapValues(_+2)

    //对文件来说，textFile读进来一行作为一个元素(map)，因此count=line
    sc.textFile("file:///opt/mydata/olddata/data1.txt").count()

    rdd.sum()
    rdd.max()
    rdd.min()

  }