数据处理五之去重

1. 数据
   file1：

2012-3-1 a
2012-3-2 b
2012-3-3 c
2012-3-4 d
2012-3-5 a
2012-3-6 b
2012-3-7 c
2012-3-3 c

file2：

2012-3-1 b
2012-3-2 a
2012-3-3 b
2012-3-4 d
2012-3-5 a
2012-3-6 c
2012-3-7 d
2012-3-3 c

1. 需求

2. 逻辑

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

object DealDataExample5 {
  def main(args: Array[String]): Unit = {
    /*if(args.length!=2){
      println("cn.edu360.Example.DealDataExample5 <input> <output>")
      sys.exit()
    }*/
    //定义参数
    //val Array(input,output)=args
    //获取数据
    val conf: SparkConf = new SparkConf()
      .setMaster("local[1]")
      .setAppName(DealDataExample5.getClass.getSimpleName)
      //.set("mapreduce.framework.name", "yarn")
        //RDD数据在序列化之后是否进一步进行压缩再储存到内存或磁盘上。
      //.set("spark.rdd.compress", "true")
        //Kryo序列化相关优化配置,
        //而Spark Task的序列化是通过spark.closure.serializer来配置，但是目前只支持JavaSerializer，
      //.set("spark.serializer","org.apache.spark.serializer.KryoSerializer")
        //spark.storage.memoryFraction则决定了每个Executor可用内存中有多少可以用于Memory Store管理RDD Cache数据，
        // 剩下的内存用来保证任务运行时各种其它内存空间的需要。
      //.set("spark.storage.memoryFraction", "0.5")
        //spark.akka.frameSize: 控制Spark中通信消息的最大容量 （如 task 的输出结果）默认为10MB
      //.set("spark.akka.frameSize", "100")

      /**
        * Akka是JVM平台上构建高并发、分布式和容错应用的工具包和运行平台。
        * Akka是用 Scala语言编程的一个并发编程框架，该框架基于Actor编程模型。
          Akka实现并发，基于Actor模式，
          相当于Java实现并发，基于Thread。
        */
        //spark.default.parallelism: 控制Spark中的分布式shuffle过程默认使用的task数量，默认为8个。
      //.set("spark.default.parallelism", "1")

    val sc = new SparkContext(conf)
    val data = sc.textFile("ExampleData/DealDataExample5/input/")
    //筛选
    val selectRes: RDD[String] = data.filter({
      t =>
        t.trim().length > 0
    })
    //println(selectRes.collect().toBuffer)
    //和1组合
    val combyRes: RDD[(String, String)] = selectRes.map(t =>(t.trim,"1"))
    //println(combyRes.collect().toBuffer)
    //去重
    val disRes: RDD[(String, String)] = combyRes.distinct()
    //println(disRes.collect().toBuffer)
    //分组
    val reduceRes: RDD[(String, String)] = disRes.reduceByKey(_+_).distinct()
    //println(reduceRes.collect().toBuffer)
    //排序
    val sortRes: RDD[(String, String)] = reduceRes.sortByKey()

    //写出到文件
    sortRes.saveAsTextFile("ExampleData/DealDataExample5/output/")
    sc.stop()
  }
}

1. 结果
   (2012-3-1 a,1)
   (2012-3-1 b,1)
   (2012-3-2 a,1)
   (2012-3-2 b,1)
   (2012-3-3 b,1)
   (2012-3-3 c,1)

(2012-3-4 d,1)
(2012-3-5 a,1)
(2012-3-6 b,1)
(2012-3-6 c,1)
(2012-3-7 c,1)
(2012-3-7 d,1)