Transformation操作

object Transformation {
def main(args: Array[String]): Unit = {
//权限被拒绝加下面代码

System.setProperty("HADOOP_USER_NAME", "root")

val conf = new SparkConf()
  .setAppName("WordCount2000")
  .setMaster("local")

val sc = new SparkContext(conf)

//textFile一个 block 对应一个Spark 的一个分区，一个分区对应一个 task

//    val lines = sc.textFile("hdfs://192.168.0.101:8020/number1.txt")
//    val lines1 = sc.textFile("hdfs://192.168.0.101:8020/number2.txt")

//map

//输出多条数据，输出多条数据
//一条记录调用一次，参数函数的处理逻辑
//将原来RDD中的每个元素通过map算子中的用户自定义函数 f 映射，
//转变为一个新的元素，然后返回一个新的RDD
//这个返回的数据集依旧是一个分布式的RDD数据集
//def map[U: classTag](f: T => TraversableOnce[U]): RDD[U] = withScop {}
//_.split("\t")(0) <=> 用户自定义函数f

// val words = lines.map(_.split("\t")(0))

//flatMap(f: T=>U)
//输入一条数据，数据多少条数据
// def flatmap[U: classTag](f: T => TraversableOnce[U]): RDD[U] = withScop {}
//flat 把一行多列的数据压扁成多行单列 ==> 列转行
//spark spark hadoop
//spart
//spark
//hadoop
//.split("\t")(0)
//spark 字符串是字符数组
//s 字符
//p 字符
//a 字符
//r 字符
//k 字符
//map(.substring(1,2)) 截取单词的个个数1是从1开始到2停下 也就是2 1不会输出

//    val worlds = lines.map(_.split("\t"))
//    val a = worlds.flatMap(x =>x).map(_.substring(1,2))foreach(println(_))

//filter(f :T=>Bool)

//def filter(f: T => Boolean): RDD[T] = withScone{}
//输出的数据集合一定是输入数据集合的 子集(也就是相同的)
//一条记录调用一次 参数函数的处理逻辑
//过滤数据一定是一条记录去过滤的

//    val filterData = lines.filter(_.contains("hadoop")).foreach(println(_))

//reduceByKey

//函数的重载 //reduceByKey 一定是作用于 key-value 格式的数据集上

//def reduceByKey(func: (V, V) =>V): RDD[(k,v)] = self.withScope {}
//def reduceByKey(func: (V, V) =>V, numPartitions: Int): RDD[(k,v)] = self.withScope {}

//    val tuple = lines.map((_,1))
//    val d = tuple.reduceByKey(_ + _) 下面一行代码也行
//    val cnt = tuple.reduceByKey((x,y) =>x+y)
//    cnt.foreach(println(_))
//    cnt.foreach(x =>println(x._1 +"拼接"+x._2)) 遍历到控制台
//    val s = cnt.map(x =>x._1 +"拼接"+x._2)  输出到集群

//sortByKey

//一定是作用于key-value 格式的数据集上的

//    val tuple = lines.map(_.split("\t")(0)).map(_.toInt).map((_,1))
//    val sortData = tuple.reduceByKey(_ + _)
//      .map(x => (x._2,x._1)).sortByKey(true ).map(x => (x._2 +"\t"+ x._1))
//      .foreach(println(_))

//sortBy

//    val sortData = lines.map(_.split("\t")(0)).map(_.toInt).sortBy(x =>x,true)
//    .foreach(println(_))

//untin 将两个文件传进来 同时进行操作，并不进行去重操作，保存所有元素。如果想去重，可以使用distinct（）。

//      val tuple =lines.union(lines1).foreach(println(_)) //第一种
//      val tuple = (lines++lines1).foreach(println(_))  //第二种操作符 ++

//distinct去重

//    val tuple = lines.distinct()
//    tuple.saveAsTextFile("hdfs://192.168.0.101:8020/opt1/out/wce")

//groupBy

//(4,CompactBuffer(4, 4, 4, 4))
//(8,CompactBuffer(8))
//(7,CompactBuffer(7, 7))
//(5,CompactBuffer(5, 5))
//(6,CompactBuffer(6))
//(2,CompactBuffer(2, 2, 2, 2, 2))
//(9,CompactBuffer(9, 9))
//(3,CompactBuffer(3, 3, 3, 3, 3))
//(1,CompactBuffer(1, 1, 1))

//  val gp = lines.groupBy(x =>x)

//4 4
//8 1
//7 2
//5 2
//6 1
//2 5
//9 2
//3 5
//1 3

//    val resStr = gp.map(x =>{
//      var strs = ""//定义一个变量
//      val sum = x._2.toList.length
//      for (s <- x._2){
//        strs = x._1 +""+x._2
//      }
//      strs = x._1 +"\t"+ sum
//      strs
//    })

//groupByKey

//(4,CompactBuffer(1, 1, 1, 1))
//(8,CompactBuffer(1))
//(7,CompactBuffer(1, 1))
//(5,CompactBuffer(1, 1))
//(6,CompactBuffer(1))
//(2,CompactBuffer(1, 1, 1, 1, 1))
//(9,CompactBuffer(1, 1))
//(3,CompactBuffer(1, 1, 1, 1, 1))
//(1,CompactBuffer(1, 1, 1))

//    val gpkeys = lines.map((_,1)).groupByKey()
//        val resStr = gp.map(x =>{
//          var strs = ""//定义一个变量
//          val sum = x._2.toList.length
//          for (s <- x._2){
//            strs = x._1 +""+x._2
//          }
//          strs = x._1 +"\t"+ sum
//          strs
//        })

//join 算子作用于在Key-Value

//    val par = lines.map(_.split("\t")).map(x =>((x(0),x(1))))
//    val par1 = lines1.map(_.split("\t")).map(x =>((x(0),x(1))))
//    val JoinData = par.join(par1)  //join 合并
//    val leftData =par.leftOuterJoin(par1) //左连接
//    val rightData = par.rightOuterJoin(par1)  //右连接
//    val fullData = par.fullOuterJoin(par1)  //全连接
//    JoinData.saveAsTextFile("hdfs://192.168.0.101:8020/opt1/out/wce")
//    JoinData.saveAsTextFile("hdfs://192.168.0.101:8020/opt1/out/wce1")
//    JoinData.saveAsTextFile("hdfs://192.168.0.101:8020/opt1/out/wce2")

//cartesian(otherDataset)：笛卡尔积, 就是m*n

//    val lines = sc.textFile("hdfs://192.168.0.101:8020/number1.txt")
//    val lines1 = sc.textFile("hdfs://192.168.0.101:8020/number2.txt")
//    val cartData = lines.cartesian(lines1)
//    cartData.saveAsTextFile("hdfs://192.168.0.101:8020/opt1/out/wce")

//foreachPartition

//    val lines = sc.textFile("hdfs://192.168.0.101:8020/number1.txt")
//    //优化问题
//    // RDD 有多少个分区就创建几个 mysql 连接
//    lines.foreachPartition(x =>{
//      //如果没学过jdbc的话看
//      //疯狂讲义
//      //java章节
//      //mysql 连接
//      x.foreach(y =>{
//        y
//      })
//    })

}

}