Scala之Transformation

package com.uplooking.bigdata.core.p2
 
import java.util.Arrays
 
import com.uplooking.bigdata.domain.Person
import org.apache.spark.{SparkConf, SparkContext}
 
import scala.collection.mutable.ArrayBuffer
 
/**
  * scala版本的关于Spark中transformation算子的操作
  *  1、map：将集合中每个元素乘以7
     2、filter：过滤出集合中的奇数
     3、flatMap：将行拆分为单词
     4、sample：根据给定的随机种子seed，随机抽样出数量为frac的数据
     5、union：返回一个新的数据集，由原数据集和参数联合而成
     6、groupByKey：对数组进行 group by key操作
     7、reduceByKey：统计每个班级的人数
     8、join：打印关联的组合信息
     9、sortByKey：将学生身高进行排序
     10、cogroup：打印每个学生的身高
  */
object ScalaSparkTransformationOps {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("ScalaSparkTransformationOps").setMaster("local")
    val sc = new SparkContext(conf)
//    transformation_1_map_Ops(sc)
//    transformation_2_filter_Ops(sc)
//    transformation_3_flatMap_Ops(sc)
//    transformation_4_sample_Ops(sc)
//    transformation_5_union_Ops(sc)
//    transformation_6_gbk_Ops(sc)
//    transormation_9_sbk_Ops(sc)
    transormation_9_sbk_Ops_1(sc)
    sc.stop()
  }
 
  /**
    * 在transormation_9_sbk_Ops的基础之上
    * 先按照姓名的升序排，如果姓名相同，再按照身高的降序排
    * @param sc
    */
  def transormation_9_sbk_Ops_1(sc:SparkContext): Unit = {
    val list: List[String] = List(
      "zhangsan 176",
      "xiaodingding 175",
      "zhangsan 173",
      "heyajie 174.5",
      "liujun 173",
      "wangxiaoxiong 150")
    val listRDD = sc.parallelize(list)
    val stuPairRDD = listRDD.map(line => {
      val splits = line.split(" ")
      val name = splits(0).trim
      val height = splits(1).trim.toDouble
      val person = new Person(name, height)
      new Tuple2[Person, String](person, null)
    })
 
    /**
      * Serialization stack:
      * 所有的数据都要进行序列
      */
    stuPairRDD.sortByKey().foreach(t => println("name: " + t._1.getName + ", height: " + t._1.getHeight))
 
 
  }
 
  def transormation_9_sbk_Ops(sc:SparkContext): Unit = {
    val list: List[String] = List(
          "zhangsan 176",
          "xiaodingding 175",
          "xiaobao 173",
          "heyajie 174.5",
          "liujun 173",
          "wangxiaoxiong 150")
    val listRDD = sc.parallelize(list)
    val pairRDD = listRDD.map(line => {
      val splits = line.split(" ")
      new Tuple2[Double, String](splits(1).trim.toDouble, splits(0).trim)
    })
    pairRDD.sortByKey(false).foreach(t => println(t._2 + " " + t._1))
 
 
  }
 
  /**
     6、groupByKey：对数组进行 group by key操作
    * @param sc
    */
  def transformation_6_gbk_Ops(sc:SparkContext): Unit = {
      val listRDD = sc.parallelize(List("hello you", "hello me", "hello me"))
      val pairRDD = listRDD.flatMap(_.split(" ")).map((_, 1))
      val gbkRDD = pairRDD.groupByKey()
      gbkRDD.foreach(println)
  }
 
  /**
    * 5、union：返回一个新的数据集，由原数据集和参数联合而成
    * @param sc
    */
  def transformation_5_union_Ops(sc:SparkContext): Unit = {
    val oddRDD = sc.parallelize(List(1, 3, 5, 7, 9))
    val evenRDD = sc.parallelize(List(2, 4, 6, 8, 10))
 
    val unionRDD = oddRDD.union(evenRDD)
    println("oddRDD Num partitions： " + oddRDD.getNumPartitions)
    println("evenRDD Num partitions： " + evenRDD.getNumPartitions)
    println("unionRDD Num partitions： " + unionRDD.getNumPartitions)
  }
  /**
    * 4、sample：根据给定的随机种子seed，随机抽样出数量为frac的数据
    * @param sc
    */
  def transformation_4_sample_Ops(sc:SparkContext): Unit = {
    val ab = ArrayBuffer[Int]()
    for(i <- 0 to 10000) {
      ab.append(i)
    }
    val listRDD = sc.parallelize(ab)
    val sampleRDD = listRDD.sample(false, 0.01)
    println("sampleRDD的数据规模：" + sampleRDD.count())
    sampleRDD.foreach(i => {print(i + " ")})
 
  }
  /**
    * 3、flatMap：将行拆分为单词
    * @param sc
    */
  def transformation_3_flatMap_Ops(sc:SparkContext): Unit = {
    sc.parallelize(List("hello you", "hello me")).flatMap(_.split(" ")).foreach(println)
  }
  /**
    * 2、filter：过滤出集合中的奇数
    * @param sc
    */
  def transformation_2_filter_Ops(sc:SparkContext): Unit = {
    val listRDD = sc.parallelize(List(1, 2, 3, 4, 5))
    listRDD.filter(_ % 2 == 0).foreach(println(_))
  }
  /*
    map(func):返回一个新的分布式数据集，由每个原元素经过func函数转换后组成
        不会改变又有rdd中的元素的个数，新生成的rdd中元素的个数和原rdd中元素的个数相等
    1、map：将集合中每个元素乘以7
   */
  def transformation_1_map_Ops(sc:SparkContext): Unit = {
 
    val listRDD = sc.parallelize(List(1, 2, 3, 4, 5))
    listRDD.map(_ * 7).foreach(println)
  }
}