spark算子基本操作

转换算子

map

def main(args: Array[String]): Unit = {
        val sparkConf = new SparkConf()
        sparkConf.setMaster("local[*]").setAppName(this.getClass.getName)
        val sc = new SparkContext(sparkConf)
          sc.setLogLevel("WARN")
        //一对一/  返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成
        val rdd1 = sc.makeRDD(1 to 10)
        val rdd2 = rdd1.map(v=>(v,1)) // val rdd2 = rdd1.map(v* 2)
            rdd2.collect().foreach(println)
//        val rdd1 = sc.makeRDD(1 to 10)
//        val rdd2 = rdd1.mapPartitions(Inter => {
//          Inter.map(v => v*2)})
//        rdd2.collect().foreach(println)
      }

mapPartitions

//mapPartition一次处理一个分区的数据
      //map每次处理一个数据
      val rdd1 = sc.makeRDD(1 to 10,2)
      val rdd2 = rdd1.mapPartitions(Inter => {
        Inter.map(v => v*2)})
      rdd2.collect().foreach(println)

flatMap  :结果为：1；1，2；1，2，3；1，2，3，4；

//类似于map，但是每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是一元素）
    val rdd1: RDD[Int] = sc.makeRDD(1 to 5)
    val rdd2: RDD[Int] = rdd1.flatMap(v => 1 to v)
      rdd2.collect().foreach(println)

glom  - 将每一个分区形成一个数组

//将每一个分区形成一个数组
    val rdd1 = sc.makeRDD(1 to 16, 4)
    val rdd2: RDD[Array[Int]] = rdd1.glom()
    rdd2.collect().foreach(v => {println(v.mkString(","))})

groupby - 分组

val rdd1: RDD[Int] = sc.makeRDD(1 to 10)
    rdd1.groupBy(v => v % 2).foreach(println)

filter - 过滤；   结果为偶数

 //filter 过滤操作
    val rdd1: RDD[Int] = sc.makeRDD(1 to 10)
    val rdd2: RDD[Int] = rdd1.filter(v => v % 2 == 0)
    rdd2.collect().foreach(println)

distinct - 去重

//对源RDD进行去重后返回一个新的RDD
    val rdd1: RDD[Int] = sc.makeRDD(List(1,3,3,4,6,6,2,10))
    val rdd2: RDD[Int] = rdd1.distinct()
    rdd2.collect().foreach(println)

coalesce - 常用于减少分区，第二个参数为true则有shuffle，否则无

//coalesce减少分区时     可以么有shuffle过程   是将分区两两合并，原分区为奇数时，容易造成数据倾斜
    //........增加分区时      有shuffle过程
    val rdd1: RDD[Int] = sc.makeRDD(1 to 10,4)
    println(rdd1.getNumPartitions)
    rdd1.glom().collect().foreach(v => {println(v.mkString(","))})
    val rdd2: RDD[Int] = rdd1.coalesce(2)
    println(rdd2.getNumPartitions)
    rdd2.glom().collect().foreach(v => {println(v.mkString(","))})
    val rdd3: RDD[Int] = rdd2.coalesce(5,true)
    println(rdd3.getNumPartitions)
    rdd3.glom().collect().foreach(v => {println(v.mkString(","))})

repartition - 常用于增加分区，底层调用了coalesce，第二个参数为true

 //repartition分区在增加或减少时，都有shuffle过程
    val rdd1: RDD[Int] = sc.makeRDD(1 to 10,5)
    val rdd2: RDD[Int] = rdd1.repartition(4)
    rdd2.collect().foreach(println)
    val rdd3: RDD[Int] = rdd1.repartition(8)
    rdd3.collect().foreach(println)

sortBy - 默认升序，第二个参数为false时为降序

//sortBy对原RDD排序，默认时升序，
    val rdd1: RDD[Int] = sc.makeRDD(List(1, 3, 4, 65, 43, 23, 12))
    val rdd2: RDD[Int] = rdd1.sortBy(v => v,false)
    rdd2.collect().foreach(println)

union - 求两个rdd的并集  

//union 求两个RDD的并集
    val rdd1: RDD[Int] = sc.makeRDD(1 to 3)
    val rdd2: RDD[Int] = sc.makeRDD(3 to 5)
    rdd1.union(rdd2).distinct.collect().foreach(println)

subtract - 计算差的一种函数，从第一个RDD中减去第二个RDD的交集部分

//subtract 计算差的一种函数，从第一个RDD中减去第二个RDD的交集部分
    val rdd1: RDD[Int] = sc.makeRDD(1 to 3)
    val rdd2: RDD[Int] = sc.makeRDD(3 to 5)
    rdd1.subtract(rdd2).collect().foreach(println)

intersection - 对RDD求交集

groupbykey

reducebykey

aggregatebykey

 

sortbykey

mapValues

 join

//join 在类型为K,V和K,W的RDD上调用，返回一个相同的key对应的所有元素在一起的（K,（K,W））的RDD
    //类似于sql的内连接，也可左连接
    //1.创建一个RDD
    val rdd1: RDD[(Int,String)] = sc.makeRDD(List((1,"a"),(2,"b"),(3,"c"),(4,"d")))
    val rdd2: RDD[(Int,Int)] = sc.makeRDD(List((1,4),(2,5),(3,6)))
    //2.join操作
    val rdd3: RDD[(Int, (String, Option[Int]))] = rdd1.leftOuterJoin(rdd2)
    //3.打印
    rdd3.collect().foreach(println)

行动算子

reduce

collect

count

first

take

takeOrdered

aggregate

fold

foreach

countbykey

saveAsTextFile(path)

saveAsSequenceFile(path)

saveAsObjectFile(path)