RDD wordCount 算子(总结)

RDD wordCount 算子(总结)

之前我们学了很多的算子，好像都能用来做wordcount，所以我们来总结一下吧，哪些算子可以做wordcount。
总结了一下，之前学了的方法大概可以用十种方法来做WordCount。
例如：groupBy，groupByKey，reduceByKey，aggregateByKey，foldByKey，combineByKey，countByKey，countByValue 由于，reduce和fold太复杂了，那两个方法就先不用了。
这八个方法里面强烈推荐使用 reduceByKey，countByKey，countByValue 这三个算子，reduceByKey 算子性能非常高，countByKey，这个算子本身就是wordcount，非常的快捷，类型需要键值对。countByValue 这个算子最最快捷，直接这个方法就出来了。
注意：无论用哪个算子进行wordcount，都要先用flatMap(_.split(" "))算子进行扁平映射处理。

package com.atguigu.bigdata.spark.core.wc.action

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

import scala.collection.mutable

//让我们总结一下，哪些算子可以做WordCount
class Spark05_wordcount {

}
object Spark05_wordcount{
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val context = new SparkContext(conf)
    wordCount1(context) //这里是调用方法
    println("===========")
    wordCount2(context)
    println("===========")
    wordCount3(context)
    println("===========")
    wordCount4(context)
    println("===========")
    wordCount5(context)
    println("===========")
    wordCount6(context)
    println("===========")
    wordCount7(context)
    println("===========")
    wordCount8(context)
    

    //groupBy 是wordcount的核心算子，通过groupBy方法相同的单词都分到一个组，只需要获取这个组的长度就行了
    def wordCount1(context:SparkContext):Unit={ //参数是配置文件,SparkContext、类型的
      val rdd = context.makeRDD(List("Hello Scala","Hello Spark"))
      val mapRDD = rdd.flatMap(_.split(" "))
      val group: RDD[(String, Iterable[String])] = mapRDD.groupBy(word => word) //相同的单词分到一个组里面
      val result: RDD[(String, Int)] = group.mapValues(iter => iter.size) //因为是一个迭代器，获取size
      result.collect().foreach(println)
    }

    //groupByKey: 需要key-value类型，自动根据key进行分组
    def wordCount2(context:SparkContext):Unit={ //参数是配置文件,SparkContext、类型的
      val rdd = context.makeRDD(List("Hello Scala","Hello Spark"))
      val mapRDD = rdd.flatMap(_.split(" "))
      val mapRDD2 = mapRDD.map((_, 1))
      val groupRDD: RDD[(String, Iterable[Int])] = mapRDD2.groupByKey()
      val result = groupRDD.mapValues(iter => iter.size)
      result.collect().foreach(println)
    }

    //reduceByKey: 需要key-value类型，直接根据key两两相加 效率很高
    def wordCount3(context:SparkContext):Unit={ //参数是配置文件,SparkContext、类型的
      val rdd = context.makeRDD(List("Hello Scala","Hello Spark"))
      val mapRDD = rdd.flatMap(_.split(" "))
      val mapRDD2 = mapRDD.map((_, 1))
      val reduceRDD: RDD[(String, Int)] = mapRDD2.reduceByKey(_ + _)//直接根据key两两相加
      reduceRDD.collect().foreach(println)
    }

    //aggregateByKey: 需要key-value类型，有个初始值，然后直接进行分区内计算，和分区间计算
    def wordCount4(context:SparkContext):Unit={ //参数是配置文件,SparkContext、类型的
      val rdd = context.makeRDD(List("Hello Scala","Hello Spark"))
      val mapRDD = rdd.flatMap(_.split(" "))
      val mapRDD2 = mapRDD.map((_, 1))
      val result = mapRDD2.aggregateByKey(0)(_ + _, _ + _)
      result.collect().foreach(println)
    }

    //foldByKey: 需要key-value类型，当分区规则相同时，可以简化为foldByKey
    def wordCount5(context:SparkContext):Unit={ //参数是配置文件,SparkContext、类型的
      val rdd = context.makeRDD(List("Hello Scala","Hello Spark"))
      val mapRDD = rdd.flatMap(_.split(" "))
      val mapRDD2 = mapRDD.map((_, 1))
      val result: RDD[(String, Int)] = mapRDD2.foldByKey(0)(_ + _)
      result.collect().foreach(println)
    }

    //combineByKey: 需要key-value类型，有三个参数，第一个参数是将第一个数据进行转换，作为第一个数据
    //然后第二个参数是分区内计算，第三个参数是分区间计算
    def wordCount6(context:SparkContext):Unit={ //参数是配置文件,SparkContext、类型的
      val rdd = context.makeRDD(List("Hello Scala","Hello Spark"))
      val mapRDD = rdd.flatMap(_.split(" "))
      val mapRDD2 = mapRDD.map((_, 1))
      val result: RDD[(String, Int)] = mapRDD2.combineByKey(
        v => v,
        (x: Int, y) => x + y, //分区内计算
        (x: Int, y: Int) => x + y //分区间计算
      )
      result.collect().foreach(println)
    }

    //countByKey: 需要key-value类型，直接这个方法就出来了，非常推荐使用这个方法
    def wordCount7(context:SparkContext):Unit={ //参数是配置文件,SparkContext、类型的
      val rdd = context.makeRDD(List("Hello Scala","Hello Spark"))
      val mapRDD = rdd.flatMap(_.split(" "))
      val mapRDD2 = mapRDD.map((_, 1))
      val result: collection.Map[String, Long] = mapRDD2.countByKey()
      println(result)
    }

    //countByValue: 不需要key-value类型，单值类型就行了，有单词直接就统计了
    def wordCount8(context:SparkContext):Unit={ //参数是配置文件,SparkContext、类型的
      val rdd = context.makeRDD(List("Hello Scala","Hello Spark"))
      val mapRDD = rdd.flatMap(_.split(" "))
      val result: collection.Map[String, Long] = mapRDD.countByValue()
      println(result)
    }
    
    context.stop()
  }
}