spark算子

SparkContext

   val conf: SparkConf = new SparkConf().setMaster("local")
    conf.setAppName("sparkTest")
    val sc = new SparkContext(conf)
    val rdd1: RDD[Int] = sc.parallelize(List(1,2,3,4,5,6))
    。。。。。
    sc.stop()

sc.makeRDD()底层调用的是 .parallelize()

map .mapPartitions .mapPartitionsWithIndex

.map(x=>x*2)   //是按照每个元素传入一次，一对一。

rdd1.mapPartitions()     //是按照每个分区传入一次 ， 例如在内部连接数据库，每个分区只需要连接一次数据库 
.mapPartitionsWithIndex()   //带有分区编号

val rdd=sc.parallelize(Seq("hello world","hello java","hello hadoop"),2)
    rdd.flatMap(x=>x.split(" "))
      .mapPartitionsWithIndex((index,x)=>{
        println("分区数： "+index)
        x.map(x=>x.toUpperCase)
      }
      ).foreach(x=>println(x))
结果：
分区数： 0
HELLO
WORLD
20/09/12 16:06:22 INFO Executor: Finished task 0.0 in stage 0.0 (TID 0). 671 bytes result sent to driver
分区数： 1
HELLO
JAVA
HELLO
HADOOP

//=======================================================
rdd1.mapPartitions(x=>{   //是一个 Iterator[T]
    x.map(x=>x*2) //此处的 .map() 是scala  的方法，不是spark的
}) 

filter

.sample

val rdd = sc.parallelize(Range(1,10))
    rdd.sample(false,0.6)
      .foreach(x=>print(x))

.sample的两个参数：
 1.表示是否又放回   FALSE不放回
 2.表示拿出总数的比值  Double

.mapVlaues  对二元数据（k，v）中的 v 值进行转换

.mapVlaues 只对value 操作。map作用于整条数据

val rdd = sc.parallelize(Seq(("a",1), ("b",2), ("c",3)))
    rdd.mapValues(x=> x*2)
      .foreach(x=>println(x))

(a,2)
(b,4)
(c,6)

集合操作：交集 并集 差集

 val rdd = sc.parallelize(Seq(1,2,3,4))
    val rdd2 = sc.parallelize(Seq(3,4,5,6))
    rdd.intersection(rdd2)  //交
    rdd.union(rdd2)     //并
    rdd.subtract(rdd2)  //差

.reduceByKey

按照key分组，然后把每组数据聚合     ,在map端做Combiner  可以减少IO

.groupByKey

在map端做Combiner  没有意义

 val rdd = sc.parallelize(Seq(("a",1), ("a",2), ("c",3)))
    rdd.groupByKey()
      .foreach(println(_))

(a,CompactBuffer(1, 2))
(c,CompactBuffer(3))
===========================================

combineByKey

reduceByKey 和 groupByKey 底层是combineByKey

foldByKey

foldByKey和spark中reduceByKey 区别是   可以指定初始值 

spark中的foldByKey 与 scala中的  foldByKey  得出的值是有差别的

scala中foldByKey(10)() 中的基数  只会加一次

spark中的foldByKey(10)() 中的基数 没传入一个数 都会加一次 基数

val rdd = sc.parallelize(Seq(("a",1), ("a",1), ("c",1)))
    rdd.foldByKey(10)((x,y)=>x+y)
      .foreach(println(_))

(a,12)   10+1+1   // 奇怪 ！！  应该 为22=10+1 + 10 + 1
(c,11)   10+1   // 奇怪 ！！  应该 为  11=10+1  

.foldByKey()()

aggregateByKey

foldByKey底层是 aggregateByKey

针对每个数据先处理 后聚合的场景

  val rdd = sc.parallelize(Seq(("手机",10.0), ("手机",10.0), ("电脑",20.0)))
    rdd.aggregateByKey(0.8)((x,y)=>x*y, (a,b)=>a+b) //此处的x为前面传入的0.8
      .foreach(println(_))

排序 sortBy  sortByKey

sortBy可以作用于任何类型的rdd   sortByKey只有 k v 类型数据rdd使用
sortBy可以按照任何部分排序        sortByKey只能按照 key 排序

@Test
  def  test9(): Unit ={
    val rdd = sc.parallelize(Seq(2,3,1,5,1,2,8,3))
    val rdd2 = sc.parallelize(Seq(("a",3),("d",2),("v",7),("f",1)))
    rdd.sortBy(x=>x)
    rdd2.sortBy(x=>x)     //按照 k 排序
      .foreach(println(_))
    
    rdd2.sortBy(x=>x._2)
      .foreach(println(_))

    rdd2.sortByKey()
      .foreach(println(_))
  }

 

控制并行度 分区数

repartition(num)
coalesce(num,shuffle=false)  //   shuffle=false不能增加分区数，只能减少   shuffle=true  可以增加分区数

 

转换  map mapPartitions   mapValues
过滤
聚合操作