spark-RDD的两大方法


 RDD方法又称为RDD算子

RDD转换算子

RDD 根据数据处理方式的不同将算子整体上分为Value 类型、双 Value 类型和Key-Value类型。

一、单Value类型(一个数据源)

1. map函数

函数签名:def map[U: ClassTag](f: T => U): RDD[U]

函数说明:将处理的数据逐条进行映射转换,这里的转换可以是类型的转换,也可以是值的转换。

示例:

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = map
    val rdd = sc.makeRDD(List(1, 2, 3, 4))
    // 1,2,3,4 => 2,4,6,8

    def mapFunction(num:Int): Int = {
      num * 2
    }
    //转换算子,将一个旧的RDD加上(num * 2)获得一个新的RDD
    val mapRDD: RDD[Int] = rdd.map(mapFunction)

    mapRDD.collect().foreach(println)
    sc.stop()
  }

}

1.1 小功能:从服务器日志数据 apache.log 中获取用户请求URL 资源路径

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark_RDD_Operator_Transform_Test {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = map
    val rdd = sc.textFile("datas/apache.log")

    //长字符串 =>短字符串
    val mapRDD: RDD[String] = rdd.map(
      line => {
        val datas = line.split(" ")
        datas(6)
      }
    )
    mapRDD.collect().foreach(println)

    sc.stop()
  }

}

补充:分区内有序执行,分区外无序执行。

2. mapPartitions函数

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark02_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = map
    val rdd = sc.makeRDD(List(1,2,3,4),2)

    //mapPartitions可以以分区为单位进行转换操作
    //但是会将整个分区的数据加载到内存进行引用
    //如果处理完的数据是不会被释放掉,存在对象的引用。
    //在内存较小,数据量较大的场合下,容易出现内存溢出。
    val mpRDD: RDD[Int] = rdd.mapPartitions(
      iter => {
        println(">>>>>>>>>>>>>")
        iter.map(_ * 2)

      }
    )

    mpRDD.collect().foreach(println)
    sc.stop()
  }

}

函数签名:

def mapPartitions[U: ClassTag]( f: Iterator[T] => Iterator[U],

preservesPartitioning: Boolean = false): RDD[U]

函数说明:将待处理的数据以分区为单位发送到计算节点进行处理,这里的处理是指可以进行任意的处理,哪怕是过滤数据。

 2.1 获取每个数据分区的最大值。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark02_RDD_Operator_Transform_test {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = map
    val rdd = sc.makeRDD(List(1,2,3,4),2)
    //[1,2],[3,4]两个分区
    //mapPartitions因为是以分区为单位,所以可以获得每个分区的最大值:[2],[4]
    val mpRDD = rdd.mapPartitions(
      iter => {
        List(iter.max).iterator
      }
    )
    mpRDD.collect().foreach(println)

    sc.stop()
  }

}

2.2 map和mapPartitions的区别:

  • 数据处理角度:Map 算子是分区内一个数据一个数据的执行,类似于串行操作。而 mapPartitions 算子是以分区为单位进行批处理操作。
  • 功能角度:Map 算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。MapPartitions 算子需要传递一个迭代器,返回一个迭代器,没有要求的元素的个数保持不变, 所以可以增加或减少数据。
  • 性能角度:

    Map 算子因为类似于串行操作,所以性能比较低,而是 mapPartitions 算子类似于批处理,所以性能较高。但是mapPartitions 算子会长时间占用内存,那么这样会导致内存可能不够用,出现内存溢出的错误。所以在内存有限的情况下,不推荐使用。使用 map 操作。

3. mapPartitionsWithIndex函数

函数签名:

def mapPartitionsWithIndex[U: ClassTag]( f: (Int, Iterator[T]) => Iterator[U],

preservesPartitioning: Boolean = false): RDD[U]

函数说明:将待处理的数据以分区为单位发送到计算节点进行处理,这里的处理是指可以进行任意的处理,哪怕是过滤数据,在处理时同时可以获取当前分区索引。

 3.1 小功能:获取第二个数据分区的数据

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark03_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = map
    val rdd = sc.makeRDD(List(1,2,3,4),2)
    //[1,2],[3,4],保留第二个数据
    val mpiRDD = rdd.mapPartitionsWithIndex(
      (index,iter) => {
        if(index == 1) {
          iter
        } else {
          Nil.iterator
        }
      }
    )
    mpiRDD.collect().foreach(println)

    sc.stop()
  }

}

4. flatMap函数

函数签名:def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]

函数说明:将处理的数据进行扁平化后再进行映射处理,所以算子也称之为扁平映射。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark04_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = map
    val rdd:RDD[List[Int]] = sc.makeRDD(List(
      List(1,2),List(3,4)
    ))
    //想要的最终结果是把1,2,3,4独立拿出来使用

    val flatRDD: RDD[Int] = rdd.flatMap(
      list => {
        list
      }
    )
    flatRDD.collect().foreach(println)
    sc.stop()
  }

}

4.1 小功能:将 List(List(1,2),3,List(4,5))进行扁平化操作

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark04_RDD_Operator_Transform1 {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = map
    val rdd = sc.makeRDD(List(List(1,2),3,List(4,5)))
    //小功能:将 List(List(1,2),3,List(4,5))进行扁平化操作
    //因为数据有不同的类型,进行模式匹配:case

    val flatRDD = rdd.flatMap(
      data => {
        data match {
          case list: List[_] => list
          case dat => List(dat)
        }
      }
    )
    flatRDD.collect().foreach(println)
    sc.stop()
  }

}

5. glom方法

函数签名:def glom(): RDD[Array[T]]

函数说明:将同一个分区的数据直接转换为相同类型的内存数组进行处理,分区不变。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark05_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = glom
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),2)
    //list => int
    //int => array
    val glomRDD: RDD[Array[Int]] = rdd.glom()

    glomRDD.collect().foreach(data => println(data.mkString(",")))
    //将一个分区的数据形成一个数组
    sc.stop()
  }

}

5.1 小功能:计算所有分区最大值求和(分区内取最大值,分区间最大值求和)

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark05_RDD_Operator_Transform_test {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = glom
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),2)
    //[1,2],[3,4]
    //计算所有分区最大值求和(分区内取最大值,分区间最大值求和)
    //最大值:[2],[4],
    // 分区间求和:[6]
    val glomRDD: RDD[Array[Int]] = rdd.glom()

    val maxRDD: RDD[Int] = glomRDD.map(
      Array => {
        Array.max
      }
    )

    println(maxRDD.collect().sum)
    //将一个分区的数据形成一个数组
    sc.stop()
  }

}

6. groupBy方法

函数签名:def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]

函数说明:将数据根据指定的规则进行分组, 分区默认不变,但是数据会被打乱重新组合,我们将这样的操作称之为shuffle。极限情况下,数据可能被分在同一个分区中。一个组的数据在一个分区中,但是并不是说一个分区中只有一个组。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark06_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = groupBy
    //实现分组
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),2)
    /*
    groupBy会将数据源中的每一个数据进行分组判断,根据返回的分组key进行分组
    相同的key值的数据会放置在同一个组中
     */
    def groupFunction(num:Int) = {
      num % 2
    }

    val groupRDD: RDD[(Int,Iterable[Int])] = rdd.groupBy(groupFunction)

    groupRDD.collect().foreach(println)
    sc.stop()
  }

}
/*
结果:
(0,CompactBuffer(2, 4))
(1,CompactBuffer(1, 3))
余数是0的放在一起,余数是1的放在一起。
 */

6.1 小功能:将 List("Hello", "hive", "hbase", "Hadoop")根据单词首写字母进行分组。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark06_RDD_Operator_Transform_1 {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = groupBy
    //实现分组
    val rdd = sc.makeRDD(List("Hello", "hive", "hbase", "Hadoop"),2)
    /*
    groupBy会将数据源中的每一个数据进行分组判断,根据返回的分组key进行分组
    相同的key值的数据会放置在同一个组中
     */

    val groupRDD = rdd.groupBy(_.charAt(0))

    groupRDD.collect().foreach(println)
    sc.stop()
  }

}
/*
结果:
(h,CompactBuffer(hive, hbase))
(H,CompactBuffer(Hello, Hadoop))
 */

7. filter函数

函数签名:def filter(f: T => Boolean): RDD[T]

函数说明:将数据根据指定的规则进行筛选过滤,符合规则的数据保留,不符合规则的数据丢弃。当数据进行筛选过滤后,分区不变,但是分区内的数据可能不均衡,生产环境下,可能会出现数据倾斜。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark07_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = filter
    //实现分组
    val rdd = sc.makeRDD(List(1,2,3,4))
    //实现:保留奇数,舍去偶数
    val filterRDD = rdd.filter(num => num % 2 != 0)
    
    filterRDD.collect().foreach(println)
    sc.stop()
  }

}
/*
结果:
1
3
 */

7.1 小功能:从服务器日志数据 apache.log 中获取 2015 年 5 月 17 日的请求路径

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark07_RDD_Operator_Transform_test {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = filter
    //实现分组
    val rdd = sc.textFile("datas/apache.log")
    //从服务器日志数据 apache.log 中获取 2015 年 5 月 17 日的请求路径
    rdd.filter(
      line => {
        val datas = line.split(" ")
        datas
        val time = datas(3)
        time.startsWith("17/05/2015")
      }
    ).collect().foreach(println)

    sc.stop()
  }

}

8. sample函数

函数签名:

def sample( withReplacement: Boolean, fraction: Double,

seed: Long = Utils.random.nextLong): RDD[T]

函数说明:根据指定的规则从数据集中抽取数据。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark08_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = sample
    //实现分组
    val rdd = sc.makeRDD(List(1,2,3,4,5,6,7,8,9,10))
    //实现:根据指定的规则从数据集中抽取数据
    /*
    sample有三个参数:
    1. 表示抽取数据是否放回
    2.表示每条数据可能被抽取的概率
      如果抽取不放回,该参数代表数据源中每条数据被抽取的概率
      如果抽取放回,该参数代表数据源中的每条数据被抽取的可能次数
      2.1 基准值的概念:
    3.表示抽取的数据的随机算法的种子
      3.1 如果不传递第三个参数,那么使用的是当前系统时间
     */
    println(rdd.sample(
      true,
      //0.4,
      1

    ).collect().mkString(","))

    sc.stop()
  }
}
/*
结果:
4,8,8,9
多次运行会发现,该随机数是伪随机,就是多次的结果一样
也就是第二个参数确定,则随机种子就确定,值确定
 */

用途:来检验数据倾斜是由于哪些数据造成的。

9. distinct函数

函数签名:

def distinct()(implicit ord: Ordering[T] = null): RDD[T]

def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]

函数说明:将数据集中重复的数据去重。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark09_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = sample
    //实现分组
    val rdd = sc.makeRDD(List(1,2,3,4,1,2,3,4))
    //实现:将数据集中重复的数据去重
    val rdd1: RDD[Int] = rdd.distinct()
    rdd1.collect().foreach(println)

    sc.stop()
  }
}

/*
结果:
1,2,3,4
 */

10. coalesce函数

函数签名:

def coalesce(numPartitions: Int, shuffle: Boolean = false,

partitionCoalescer: Option[PartitionCoalescer] = Option.empty) (implicit ord: Ordering[T] = null)

: RDD[T]

函数说明:根据数据量缩减分区,用于大数据集过滤后,提高小数据集的执行效率,当 spark 程序中,存在过多的小任务的时候,可以通过 coalesce 方法,收缩合并分区,减少分区的个数,减小任务调度成本。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark10_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = coalesce
    //根据数据量缩减分区,用于大数据集过滤后,提高小数据集的执行效率
    val rdd = sc.makeRDD(List(1,2,3,4,5,6),3)
    //实现:缩减分区
    /*
    coalesce方法默认情况下不会将分区的数据打乱重新组合。
    也就是相同分区的数据不会拆开,依然放到同一个分区里
    这种情况下缩减分区可能会导致数据不均衡,出现数据倾斜
    为了防止这种问题,我们可以进行shuffle处理,也就是将第二个参数改成true
     */
    val newRDD: RDD[Int] = rdd.coalesce(2,true)
    newRDD.saveAsTextFile("output")

    sc.stop()
  }
}

/*
结果:
 */

11. reparation函数

函数签名:def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]

函数说明:该操作内部其实执行的是 coalesce 操作,参数 shuffle 的默认值为 true。无论是将分区数多的RDD 转换为分区数少的RDD,还是将分区数少的 RDD 转换为分区数多的RDD,repartition 操作都可以完成,因为无论如何都会经 shuffle 过程。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark11_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = repartition
    //根据数据量改变分区
    val rdd = sc.makeRDD(List(1,2,3,4,5,6),2)
    //实现:扩大分区
    /*
    底层代码就是用的coalesce
     */
    val newRDD: RDD[Int] = rdd.repartition(3)
    newRDD.saveAsTextFile("output")

    sc.stop()
  }
}

/*
结果:
 */

12. sortBy

函数说明:该操作用于排序数据。在排序之前,可以将数据通过 f 函数进行处理,之后按照 f 函数处理的结果进行排序,默认为升序排列。排序后新产生的 RDD 的分区数与原RDD 的分区数一致。中间存在 shuffle 的过程。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark12_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = sortBy
    //数据排序,全局有序,所有数据先都拿出来排序,排完在分区
    val rdd = sc.makeRDD(List(6,5,4,3,2,1),2)
    val newRDD: RDD[Int] = rdd.sortBy(num => num)
    newRDD.saveAsTextFile("output")
    sc.stop()
  }
}

/*
结果:
 */

二、双Value类型(两个数据源)

13. intersection函数(交集)

函数签名:def intersection(other: RDD[T]): RDD[T]

函数说明:对源RDD 和参数RDD 求交集后返回一个新的RDD,求交集。

14. union函数(并集)

函数签名:def union(other: RDD[T]): RDD[T]

函数说明:对源RDD 和参数RDD 求并集后返回一个新的RDD,求并集。

15. subtract函数(差集)

函数签名:def subtract(other: RDD[T]): RDD[T]

函数说明:以一个 RDD 元素为主,去除两个 RDD 中重复元素,将其他元素保留下来。求差集。

16. zip函数(拉链)

函数签名:def zip[U: ClassTag](other: RDD[U]): RDD[(T, U)]

函数说明:将两个 RDD 中的元素,以键值对的形式进行合并。其中,键值对中的Key 为第 1 个 RDD中的元素,Value 为第 2 个 RDD 中的相同位置的元素。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark13_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = 双value类型
    val rdd1 = sc.makeRDD(List(1,2,3,4))
    val rdd2 = sc.makeRDD(List(3,4,5,6))

    //交集 [3,4]
    val rdd3: RDD[Int] = rdd1.intersection(rdd2)
    println(rdd3.collect().mkString(","))
    //并集 [1,2,3,4,3,4,5,6]
    val rdd4: RDD[Int] = rdd1.union(rdd2)
    println(rdd4.collect().mkString(","))
    //差集 [1,2]
    val rdd5: RDD[Int] = rdd1.subtract(rdd2)
    println(rdd5.collect().mkString(","))
    //拉链 [1-3,2-4,3-5,4-6]
    val rdd6: RDD[(Int,Int)] = rdd1.zip(rdd2)
    println(rdd6.collect().mkString(","))

    sc.stop()
  }
}

/*
结果:
 */
  • 交集并集差集要求两个数据源的数据类型保存一致。
  • 拉链操作两个数据源类型可以不一致,但要求两个数据源的分区数量保持一致,并且每一个分区数据数量要相同。

三、Key-Value类型

17. partitionBy函数

函数签名:def partitionBy(partitioner: Partitioner): RDD[(K, V)]

函数说明:将数据按照指定Partitioner 重新进行分区。Spark 默认的分区器是HashPartitioner。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark17_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = Key-Value类型
    val rdd = sc.makeRDD(List(1,2,3,4),2)
    val mapRDD = rdd.map((_,1))
    //partitionBy根据指定的分区规则对数据进行重分区
    mapRDD.partitionBy(new HashPartitioner(2)).saveAsTextFile("output")
    //该方法是在PairRDDFunctions里面的
    //隐式转换(二次编译),将一个类型变成另外一个类型
    sc.stop()
  }
}

/*
结果:
(2,1)
(4,1)

(1,1)
(3,1)
 */

18. reduceByKey

函数签名:def reduceByKey(func: (V, V) => V): RDD[(K, V)]

def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]

函数说明:可以将数据按照相同的Key 对Value 进行聚合。

package cn.gfs.sparkCore.rdd.operator.transform

import org.apache.spark.{HashPartitioner, SparkConf, SparkContext}

object Spark18_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = Key-Value类型
    val rdd = sc.makeRDD(List(
      ("a",1),("a",2),("a",3),("b",4)
    ))

    //reduceByKey:相同的Key进行value操作
    //scala中的菊科一般都是两两聚合,spark基于scala开发的,所以它也是两两聚合
    val reduceRDD = rdd.reduceByKey((x: Int, y: Int) => {
      x + y
    })
    //reduceByKey中如果key的数据只有一个,则不会参与运算。
    reduceRDD.collect().foreach(println)

    sc.stop()
  }
}

/*
结果:
(a,6)
(b,4)
 */

19. groupByKey函数

函数说明:将数据源的数据根据 key 对 value 进行分组。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark19_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = Key-Value类型
    val rdd = sc.makeRDD(List(
      ("a",1),("a",2),("a",3),("b",4)
    ))

    //groupByKey:将相同数据源中的数据,相同key的数据放在一个组中,形成一个对偶元组
    //          元组中的第一个元素就是key,第二个元素就是相同key的value的集合
    val groupRDD = rdd.groupByKey()
    groupRDD.collect().foreach(println)

    sc.stop()
  }
}

/*
结果:
(a,CompactBuffer(1, 2, 3))
(b,CompactBuffer(4))
 */

19.1 reduceByKey 和 groupByKey 的区别?

  • shuffle 的角度:reduceByKey 和 groupByKey 都存在 shuffle 的操作,但是reduceByKey 可以在 shuffle 前对分区内相同 key 的数据进行预聚合(combine)功能,这样会减少落盘的数据量,而groupByKey 只是进行分组,不存在数据量减少的问题,reduceByKey 性能比较高。

  • spark中,shuffle操作必须落盘处理(就是存到文件当中进行等待),不能在内存中进行数据等待,会导致内存溢出。

  • 从功能的角度:reduceByKey 其实包含分组和聚合的功能。GroupByKey 只能分组,不能聚合,所以在分组聚合的场合下,推荐使用 reduceByKey,如果仅仅是分组而不需要聚合。那么还是只能使用groupByKey。

20. aggregateByKey函数

函数说明:将数据根据不同的规则进行分区内计算和分区间计算。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark20_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = Key-Value类型-aggregateByKey
    val rdd = sc.makeRDD(List(
      ("a",1),("a",2),("a",3),("a",4)
    ),2)
    //分区内相同的key求最大值,分区间相同的key求和
    //aggregateByKey存在参数的柯里化
    //第一个参数列表:需要传递一个参数,表示为初始值
    //    主要用于当碰见第一个key的时候,和value进行分区内的计算
    //第二个参数列表:需要传递两个参数
    //    第一个参数表示分区内计算规则
    //    第二个参数表示分区间计算规则
    rdd.aggregateByKey(0)(
      (x,y) => math.max(x,y),
      (x,y) => x+y
    ).collect().foreach(println)

    sc.stop()
  }
}

/*
结果:
(a,6)
 */

20.1 求数据平均值

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark20_RDD_Operator_Transform_test {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = Key-Value类型-aggregateByKey
    val rdd = sc.makeRDD(List(
      ("a",1),("a",2),("b",3),
      ("b",4),("b",5),("a",6)
    ),2)
    //获取相同key的数据的平均值
    val newRDD = rdd.aggregateByKey((0, 0))(
      (t, v) => {
        (t._1 + v, t._2 + 1)
      },
      (t1, t2) => {
        (t1._1 + t2._1, t1._2 + t2._2)
      }
    )

    val resRDD = newRDD.mapValues {
      case (num, cnt) => {
        num / cnt
      }
    }
    resRDD.collect().foreach(println)
    sc.stop()
  }
}

/*
结果:
(b,4)
(a,3)
 */

21. foldByKey函数

函数说明:当分区内计算规则和分区间计算规则相同时,aggregateByKey 就可以简化为foldByKey。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark21_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = Key-Value类型-foldByKey
    val rdd = sc.makeRDD(List(
      ("a",1),("a",2),("b",3),
      ("b",4),("b",5),("a",6)
    ),2)
    //如果聚合计算时,分区内和分区间计算规则相同,spark提供了简化的方法foldByKey
    rdd.foldByKey(0)(_+_).collect().foreach(println)
    sc.stop()
  }
}

/*
结果:
(b,12)
(a,9)
 */

22. combineByKey函数

函数说明:最通用的对key-value 型 rdd 进行聚集操作的聚集函数(aggregation function)。类似于aggregate(),combineByKey()允许用户返回值的类型与输入不一致。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark22_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = Key-Value类型-combineByKey
    val rdd = sc.makeRDD(List(
      ("a",1),("a",2),("b",3),
      ("b",4),("b",5),("a",6)
    ),2)
    //获取相同key的数据的平均值
    /*
    combineByKey方法需要三个参数:
    第一个参数:将相同key的第一个数据进行结构的转换,实现操作
    第二个参数:分区内的计算规则
    第三个参数:分区间的计算规则
     */
    val newRDD = rdd.combineByKey(
      v =>(v,1),
      (t:(Int,Int), v) => {
        (t._1 + v, t._2 + 1)
      },
      (t1:(Int,Int), t2:(Int,Int)) => {
        (t1._1 + t2._1, t1._2 + t2._2)
      }
    )

    val resRDD = newRDD.mapValues {
      case (num, cnt) => {
        num / cnt
      }
    }
    resRDD.collect().foreach(println)
    sc.stop()
  }
}

/*
结果:
(b,4)
(a,3)
 */

思考:reduceByKey、foldByKey、aggregateByKey、combineByKey 的区别

  • reduceByKey: 相同 key 的第一个数据不进行任何计算,分区内和分区间计算规则相同。
  • FoldByKey: 相同 key 的第一个数据和初始值进行分区内计算,分区内和分区间计算规则相同。

  • AggregateByKey:相同 key 的第一个数据和初始值进行分区内计算,分区内和分区间计算规则可以不相同。

  • CombineByKey:当计算时,发现数据结构不满足要求时,可以让第一个数据转换结构。分区内和分区间计算规则不相同。

24. join函数

函数签名:def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]。

函数说明:在类型为(K,V)和(K,W)的RDD 上调用,返回一个相同 key 对应的所有元素连接在一起的(K,(V,W))的RDD。

将两个数据源中的数据相同的key连接在一起。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark24_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = Key-Value类型-combineByKey
    val rdd1 = sc.makeRDD(List(
      ("a",1),("b",2),("c",3)
    ))
    val rdd2 = sc.makeRDD(List(
      ("a",4),("b",5),("c",6)
    ))
    /*
    join:
      两个不同数据源的数据,相同的key的value会连接在一起,形成元组
      如果两个数据源中key没有匹配上,那么数据不会出现在结果中
      如果两个数据源中key有多个相同的,会依次匹配,可能会出现笛卡尔乘积,数据量会几何增长,会导致性能降低
      谨慎使用
     */
    val resRDD = rdd1.join(rdd2)
    resRDD.collect().foreach(println)
    sc.stop()
  }
}

/*
结果:
(a,(1,4))
(b,(2,5))
(c,(3,6))
 */

25. leftOuterJoin函数

函数签名:def leftOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]

函数说明:类似于 SQL 语句的左外连接。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark25_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = Key-Value类型-combineByKey
    val rdd1 = sc.makeRDD(List(
      ("a",1),("b",2),("c",3)
    ))
    val rdd2 = sc.makeRDD(List(
      ("a",4),("b",5)//,("c",6)
    ))

    val resRDD = rdd1.leftOuterJoin(rdd2)
    //val rightRDD = rdd1.rightOuterJoin(rdd2)
    resRDD.collect().foreach(println)
    sc.stop()
  }
}

/*
结果:
(a,(1,Some(4)))
(b,(2,Some(5)))
(c,(3,None))
 */

26. rightOuterJoin函数

函数说明:类似于 SQL 语句的右外连接。

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark25_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = Key-Value类型-combineByKey
    val rdd1 = sc.makeRDD(List(
      ("a",1),("b",2)//,("c",3)
    ))
    val rdd2 = sc.makeRDD(List(
      ("a",4),("b",5),("c",6)
    ))

    //val resRDD = rdd1.leftOuterJoin(rdd2)
    val rightRDD = rdd1.rightOuterJoin(rdd2)
    rightRDD.collect().foreach(println)
    sc.stop()
  }
}

/*
结果:
(a,(Some(1),4))
(b,(Some(2),5))
(c,(None,6))
 */

27. cogroup函数

函数说明:在类型为(K,V)和(K,W)的RDD 上调用,返回一个(K,(Iterable<V>,Iterable<W>))类型的 RDD。

 可以实现分组+连接:

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark27_RDD_Operator_Transform {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子 = Key-Value类型-combineByKey
    val rdd1 = sc.makeRDD(List(
      ("a",1),("b",2)//,("c",3)
    ))
    val rdd2 = sc.makeRDD(List(
      ("a",4),("b",5),("c",6),("c",6)
    ))
    /*
    cogroup:connect+group,连接+分组
     */
    val coRDD = rdd1.cogroup(rdd2)
    coRDD.collect().foreach(println)
    sc.stop()
  }
}

/*
结果:
(a,(CompactBuffer(1),CompactBuffer(4)))
(b,(CompactBuffer(2),CompactBuffer(5)))
(c,(CompactBuffer(),CompactBuffer(6, 6)))
 */

算子案例实操

package cn.gfs.sparkCore.rdd.operator.transform

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

object Spark_final_RDD_Req {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 案例实操
    /*
    数据准备:时间戳,省份,城市,用户,广告,中间字段使用空格分隔。
    需求描述:统计出每一个省份每个广告被点击数量排行的 Top3
     */
    //思路设计:
    //1. 获取原始数据
    val dataRDD = sc.textFile("datas/agent.log")
    //2. 将原始数据进行结构的转换,方便统计:((省份,广告),1)
    val mapRDD = dataRDD.map(
      line => {
        val datas = line.split(" ")
        ((datas(1), datas(4)), 1)
      }
    )
    //3. 将转换后的数据进行分组聚合:((省份,广告),sun)
    val reduceRDD: RDD[((String,String),Int)] = mapRDD.reduceByKey(_+_)
    //4. 将聚合的结果进行结构的转换:(省份,(广告,sum))
    val newmapRDD = reduceRDD.map{
      case ((prv,ad),sum) =>{
        (prv,(ad,sum))
      }
    }
    //5. 将转换后的数据根据省份进行分组:(省份,((广告A,sum),(广告B,sum)))
    val groupRDD = newmapRDD.groupByKey()
    //6. 将分组后的数据进行组内排序,降序取前三
    val resultRDD = groupRDD.mapValues(
      iter => {
        iter.toList.sortBy(_._2)(Ordering.Int.reverse).take(3)
      }
    )
    //7. 采集数据,打印控制台
    resultRDD.collect().foreach(println)

    sc.stop()
  }
}

/*
结果:
(4,List((12,25), (2,22), (16,22)))
(8,List((2,27), (20,23), (11,22)))
(6,List((16,23), (24,21), (22,20)))
(0,List((2,29), (24,25), (26,24)))
(2,List((6,24), (21,23), (29,20)))
(7,List((16,26), (26,25), (1,23)))
(5,List((14,26), (21,21), (12,21)))
(9,List((1,31), (28,21), (0,20)))
(3,List((14,28), (28,27), (22,25)))
(1,List((3,25), (6,23), (5,22)))
 */

RDD行动算子

行动算子就是触发整个计算的执行。

底层代码调用的是环境对象的runjob方法,底层代码中会创建ActionJob,并提交执行。

1. reduce方法

函数签名:def reduce(f: (T, T) => T): T

函数说明:聚集RDD 中的所有元素,先聚合分区内数据,再聚合分区间数据。(求和)

package cn.gfs.sparkCore.rdd.operator.action

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

object Spark01_RDD_Operator_Action {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    val rdd = sc.makeRDD(List(1, 2, 3, 4))
    //TODO - 行动算子: reduce
    val reRDD = rdd.reduce(_ + _)
    println(reRDD)
    sc.stop()
  }

}
/*
结果:
10
 */

2. collect方法

函数签名:def collect(): Array[T]

函数说明:在驱动程序中,以数组Array 的形式返回数据集的所有元素。

package cn.gfs.sparkCore.rdd.operator.action

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

object Spark02_RDD_Operator_Action {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    val rdd = sc.makeRDD(List(1, 2, 3, 4))
    //TODO - 行动算子:

    //collect:会将不同分区的数据按照分区顺序采集回来,形成数组
    val reRDD = rdd.collect()
    println(reRDD.mkString(","))
    sc.stop()
  }

}

/*
结果:
1,2,3,4
 */

3. count方法

函数说明:返回RDD 中元素的个数。

package cn.gfs.sparkCore.rdd.operator.action

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

object Spark03_RDD_Operator_Action {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    val rdd = sc.makeRDD(List(1, 2, 3, 4))
    //TODO - 行动算子:

    val reRDD = rdd.count()
    println(reRDD)
    sc.stop()
  }

}

/*
结果:
4
 */

4. first方法

函数说明:返回RDD 中的第一个元素。

package cn.gfs.sparkCore.rdd.operator.action

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

object Spark04_RDD_Operator_Action {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    val rdd = sc.makeRDD(List(1, 2, 3, 4))
    //TODO - 行动算子:
    //first:获取数据源中的第一个
    val reRDD = rdd.first()
    println(reRDD)
    sc.stop()
  }

}

/*
结果:
1
 */

5. take方法

函数说明:返回一个由RDD 的前 n 个元素组成的数组。

package cn.gfs.sparkCore.rdd.operator.action

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

object Spark05_RDD_Operator_Action {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    val rdd = sc.makeRDD(List(1, 2, 3, 4))
    //TODO - 行动算子:
    //take:取多少个
    val reRDD = rdd.take(3)
    println(reRDD.mkString(","))
    sc.stop()
  }

}

/*
结果:
1,2,3
 */

6. takeOrdered方法

函数说明:返回该 RDD 排序后的前 n 个元素组成的数组。

package cn.gfs.sparkCore.rdd.operator.action

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

object Spark06_RDD_Operator_Action {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    val rdd = sc.makeRDD(List(4,2,3,1))
    //TODO - 行动算子:
    //takeOrderd:先进行排序,再取多少个
    val reRDD = rdd.takeOrdered(3)
    println(reRDD.mkString(","))
    sc.stop()
  }

}

/*
结果:
1,2,3
 */

7. aggregate方法

函数说明:分区的数据通过初始值和分区内的数据进行聚合,然后再和初始值进行分区间的数据聚合。

package cn.gfs.sparkCore.rdd.operator.action

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

object Spark07_RDD_Operator_Action {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    val rdd = sc.makeRDD(List(1,2,3,4))
    //TODO - 行动算子:

    val reRDD = rdd.aggregate(0)(_+_,_+_)

    println(reRDD)
    sc.stop()
  }

}

/*
结果:
10
 */

8. fold方法

函数说明:折叠操作,aggregate 的简化版操作。

package cn.gfs.sparkCore.rdd.operator.action

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

object Spark08_RDD_Operator_Action {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    val rdd = sc.makeRDD(List(1,2,3,4),2)
    //TODO - 行动算子:
    //fold:分区内和分区间计算规则相同
    val reRDD = rdd.fold(10)(_+_)

    println(reRDD)
    sc.stop()
  }

}

/*
结果:
40
 */

9. countByKey方法

函数说明:统计每种 key 的个数。

package cn.gfs.sparkCore.rdd.operator.action

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

object Spark09_RDD_Operator_Action {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    //val rdd = sc.makeRDD(List(1,1,1,4),2)
    //TODO - 行动算子:
    //countByValue:每个值出现几次
    //val reRDD = rdd.countByValue()

    //countByKey:
    val rdd = sc.makeRDD(List(("a",1),("a",1),("a",1),("b",1)),2)
    val countRDD = rdd.countByKey()
    println(countRDD)
    sc.stop()
  }

}

/*
结果:
countByValue:List(1,2,3,4)
Map(4 -> 1, 2 -> 1, 1 -> 1, 3 -> 1)
countByKey
Map(b -> 1, a -> 3)
 */

10. save相关算子

函数说明:将数据保存到不同格式的文件中。


package cn.gfs.sparkCore.rdd.operator.action

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

object Spark10_RDD_Operator_Action {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    //countByKey:
    val rdd = sc.makeRDD(List(("a",1),("a",1),("a",1),("b",1)),2)
    rdd.saveAsTextFile("output")
    rdd.saveAsObjectFile("output1")
    //saveAsSequenceFile这个方法要求数据的格式必须为k-v类型
    rdd.saveAsSequenceFile("output2")
    //println(countRDD)
    sc.stop()
  }

}

/*
结果:

 */

11. foreach方法

函数说明: 分布式遍历RDD 中的每一个元素,调用指定函数。

12. 总结:实现wordcount的几种方法

package cn.gfs.sparkCore.rdd.operator.action

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

import scala.collection.mutable

object Spark_RDD_Operator_WordCount {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("WordCount")
    val sc = new SparkContext(sparkConf)

    wordcount1(sc)
    wordcount2(sc)
    wordcount3(sc)
    wordcount4(sc)
    wordcount5(sc)
    wordcount6(sc)
    wordcount7(sc)
    wordcount8(sc)
    sc.stop()
  }

  //groupBy
  def wordcount1(sc : SparkContext):Unit = {
    val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
    val words = rdd.flatMap(_.split(" "))
    val group = words.groupBy(word => word)
    val wordCount = group.mapValues(iter => iter.size)
  }
  //groupByKey
  def wordcount2(sc : SparkContext):Unit = {
    val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
    val words = rdd.flatMap(_.split(" "))
    val wordOne = words.map((_,1))
    val group = wordOne.groupByKey()
    val wordCount = group.mapValues(iter => iter.size)
  }
  //reduceByKey
  def wordcount3(sc : SparkContext):Unit = {
    val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
    val words = rdd.flatMap(_.split(" "))
    val wordOne = words.map((_,1))
    val wordCount = wordOne.reduceByKey(_ + _)
  }
  //aggregateByKey
  def wordcount4(sc : SparkContext):Unit = {
    val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
    val words = rdd.flatMap(_.split(" "))
    val wordOne = words.map((_,1))
    val wordCount = wordOne.aggregateByKey(0)(_+_,_+_)
  }
  //foldByKey
  def wordcount5(sc : SparkContext):Unit = {
    val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
    val words = rdd.flatMap(_.split(" "))
    val wordOne = words.map((_,1))
    val wordCount = wordOne.foldByKey(0)(_ + _)
  }
  //combineByKey
  def wordcount6(sc : SparkContext):Unit = {
    val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
    val words = rdd.flatMap(_.split(" "))
    val wordOne = words.map((_,1))
    val wordCount = wordOne.combineByKey(
      v=>v,
      (x:Int,y)=>x+y,
      (x:Int,y:Int)=>x+y
    )
  }
  //countByKey
  def wordcount7(sc : SparkContext):Unit = {
    val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
    val words = rdd.flatMap(_.split(" "))
    val wordOne = words.map((_,1))
    val wordCount = wordOne.countByKey()
  }
  //countByKey
  def wordcount8(sc : SparkContext):Unit = {
    val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
    val words = rdd.flatMap(_.split(" "))
    //val wordOne = words.map((_,1))
    val wordCount = words.countByValue()
  }
  //reduce
//  def wordcount9(sc : SparkContext):Unit = {
//    val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
//    val words = rdd.flatMap(_.split(" "))
//    val mapWord = words.map(
//      word => {
//        mutable.Map[String, Long]((word, 1))
//      }
//    )
//    //val wordOne = words.map((_,1))
//    val wordCount = mapWord.reduce(
//      (map1,map2) => {
//        map2.foreach{
//          case (word,count)=>{
//            val newCount = map1.getOrElse(word,OL)+count
//            map1.update(word,newCount)
//          }
//        }
//        map1
//      }
//    )
//    println(wordCount)
//  }
}

/*
结果:
)
 */

算子概念回顾

算子:Operator(操作)

        RDD的方法和scala集合对象的方法不一样,

        集合对象的方法都是在同一个节点的内存中完成的。

        RDD的方法可以将计算逻辑分发到Executor端(分布式节点)上执行。

        为了区分不同的处理效果,所以将RDD的方法称之为算子。

        RDD的方法外部的操作都是在Driver端执行的,而方法内部的逻辑代码是在Executor端执行。

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值