spark学习一-------------------Spark算子最详细介绍
Spark学习–spark算子介绍
1.基本概念
spark算子：为了提供方便的数据处理和计算，spark提供了一系列的算子来进行数据处理。
一般算子分为
action（执行算子）算子
Transformation（懒执行）算子。
2.Transformation算子基本介绍
简介：transformation被称为懒执行算子，如果没有action算子，则代码是不会执行的，一般分为：
- map算子：map算子是将rdd中的数据一条一条传递给后面的函数，将函数的返回值构建成一个新的rdd。map算子是不会生成shuffle。后面的分区数等于map算子的分区数。
object Demo2Map {
def main(args: Array[String]): Unit = {
//saprk代码的入口
val conf = new SparkConf()
conf.setMaster("local")
.setAppName("map")
val sc = new SparkContext(conf)
/**
* 构建rdd的方法
* 1.读取文件
* 2.基于scala的集合构建rdd ---- 用于测试
*
*/
val listRDD: RDD[Int]= sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9),2)
/**
* map算子
* 将rdd中的数据一条一条传递给后面的函数，将函数的返回值构建成一个新的rdd
* map 不会产生shuffle，map之后的分区数等于map之前rdd的分区数
*
*如果一个算子是一个新的rdd，那么这个算子就是转换算子。
*/
val mapRDD: RDD[Int] = listRDD.map{i => i * 2}
//一次遍历整个分区的数据,将每一个分区的数据传递给后面的函数，函数需要返回一个迭代器，再构建一个新的rdd。
val mapPartitionRDD: RDD[Int] = listRDD.mapPartitions {
case iter: Iterator[Int] =>
iter
}
val mapPartitionRDD2: RDD[Int] = listRDD.mapPartitions {
case iter: Iterator[Int] =>
val iterator: Iterator[Int] = iter.map(i => i * 2)
//最后一行作为返回值
iterator
}
mapPartitionRDD2.foreach(println)
mapPartitionRDD.foreach(println)
val mapPartitionsWithIndexRDD: RDD[Int] = listRDD.mapPartitionsWithIndex((index: Int, iter: Iterator[Int]) => {
println(s"mapPartitionsWithIndexRDD的分区为:$index")
iter
})
mapPartitionsWithIndexRDD.foreach(println)
}
}
- flat算子:对RDD中的数据进行过滤，通过返回true保留数据，函数返回false过滤数据。转换算子，懒执行
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Demo4Filter {
def main(args: Array[String]): Unit = {
val conf = new SparkConf()
conf.setMaster("local")
.setAppName("filter")
val sc = new SparkContext(conf)
val ListRDD: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9, 0), 2)
/**
* filter: 对RDD中的数据进行过滤，通过返回true保留数据，函数返回false过滤数据
*
* filter: 转换算子，懒执行
*/
val filterRDD: RDD[Int] = ListRDD.filter(i => {
i % 2 == 1
})
filterRDD.foreach(println)
}
}
- flatmap算子：将rdd的数据一条一条传递给后面的函数，函数的返回值是一个集合，最后将这个集合拆分出来，构建成新的rdd
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD
object Demo5Flatmap {
def main(args: Array[String]): Unit = {
val conf = new SparkConf()
conf.setMaster("local")
.setAppName("filter")
val sc = new SparkContext(conf)
val listRDD: RDD[String] = sc.parallelize(List("java,spark,java","spark,scala,hadoop"))
/**
* 将rdd的数据一条一条传递给后面的函数，函数的返回值是一个集合，
* 最后将这个集合拆分出来，构建成新的rdd
*/
val wordsRDD: RDD[String] = listRDD.flatMap(line => {
val arr: Array[String] = line.split(",")
//返回值可以是一个数组，list，set map，必须是scala中的集合
arr.toList
})
wordsRDD.foreach(println)
}
}
- Sample算子:抽样,withReplacement:是否放回。fraction：抽样比例。
package com.zjl
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Demo6Sample {
def main(args: Array[String]): Unit = {
val conf = new SparkConf()
conf.setMaster("local")
.setAppName("Demo6Sample")
val sc = new SparkContext(conf)
val listRDD: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 45, 6, 7, 8, 9, 0))
val studentRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\data\\students.txt")
/**
* sample:抽样。
* withReplacement:是否放回。
* fraction：抽样比例。
*/
val sampleRDD: RDD[String] = {
studentRDD.sample(false, 0.1)
}
}
}
- groupByKey算子:按照key进行分组，必须是kv格式的才能用，将同一个key的value放在迭代器中。相对比groupBy，指定一个分组的罗列，返回的RDD的value包含所有的列。shuffle过程中需要传输的数据量groupByKey要多，性能差一点
package com.zjl
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Demo8GroupByKey {
def main(args: Array[String]): Unit = {
val conf: SparkConf = {
new SparkConf()
}
conf.setMaster("local")
.setAppName("groupByKey")
val sc: SparkContext = new SparkContext(conf)
val linesRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data\\words.txt")
val wordsRDD: RDD[String] = linesRDD.flatMap(i => i.split(","))
val mapWordRDD: RDD[(String, Int)] = wordsRDD.map(word => (word, 1))
/**
* 按照key进行分组，必须是kv格式的才能用，将同一个key的value放在迭代器中
*/
val groupByKeyRDD: RDD[(String, Iterable[Int])] = mapWordRDD.groupByKey()
groupByKeyRDD.map({
case(words:String, ints:Iterable[Int]) =>
ints.sum
})
groupByKeyRDD.foreach(println)
/**
* groupBy:指定一个分组的罗列，返回的RDD的value包含所有的列
* shuffle过程中需要传输的数据量groupByKey要多，性能差一点
*/
val groupByRDD: RDD[(String, Iterable[(String, Int)])] = mapWordRDD.groupBy(kv => kv._1)
groupByRDD.foreach(println)
}
}
- reduceByKey算子：按照key进行聚合计算，会在map端进行预聚合，只能做简单的聚合计算。
package com.zjl
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Demo9ReduceByKey {
def main(args: Array[String]): Unit = {
val conf = new SparkConf()
.setAppName("reduceByKey")
.setMaster("local")
val sc: SparkContext = new SparkContext(conf)
val linesRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data\\words.txt")
val wordsRDD: RDD[String] = linesRDD.flatMap(i => i.split(","))
val mapRDD: RDD[(String, Int)] = wordsRDD.map(i => (i, 1))
/**
* reduceByKey：按照key进行聚合计算，会在map端进行预聚合
* 只能做简单的聚合计算
*/
//统计单词数量
val reducrByKeyRDD: RDD[(String, Int)] = mapRDD.reduceByKey((x: Int, y: Int) => x + y)
reducrByKeyRDD.foreach(println)
}
}
- union算子:合并两个rdd，两个rdd的数据类型要一致，但是只是代码层面的合并，底层没有合并。这个属于并集，如果取交集可以使用intersection算子。
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Demo10Union {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf()
conf.setMaster("local")
.setAppName("union")
val sc: SparkContext = new SparkContext(conf)
val rdd1: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9))
val rdd2: RDD[Int] = sc.parallelize(List( 4, 5, 6, 7, 8, 9,10))
/**
* union:合并两个rdd，两个rdd的数据类型要一致
* union只是代码层面的合并，底层没有合并
* union不会产生shuffle
*/
val unionRDD: RDD[Int] = rdd1.union(rdd2)
unionRDD.foreach(println)
/**
* distinctRDD去重，会产生shuffle
* distinct:会先在map端局部去重，再到reduce端全局去重
*/
val distinctRDD: RDD[Int] = unionRDD.distinct()
distinctRDD.foreach(println)
/**
* 所有会产生shuffle的算子都可以指定分区数。反过来也成立。
*/
/**
* intersection:取两个rdd的交集
*/
val interRDD: RDD[Int] = rdd1.intersection(rdd2)
interRDD.foreach(println)
}
}
- join算子:inner join:通过rdd的key进行关联，必须是kv格式的rdd；left join:以左表为主，如果右表没有数据，就会补一个null；right join和left join相反；full join:两边都可能没有关联上，如果是没关联上，补null
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Demo11Join {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf()
conf.setMaster("local")
.setAppName("join")
val sc: SparkContext = new SparkContext(conf)
val nameRDD: RDD[(String, String)] = sc.makeRDD(List(("001", "张三"), ("002", "李四"), ("003", "王五")))
val ageRDD: RDD[(String, String)] = sc.makeRDD(List(("001", "23"), ("002", "35"), ("004", "19")))
/**
* inner join:通过rdd的key进行关联，必须是kv格式的rdd
*/
// //关联之后处理数据方法1--下划线方法
val innerJoinRDD: RDD[(String, (String, String))] = nameRDD.join(ageRDD)
// innerJoinRDD.map(i=>{
// val id: String = i._1
// val name: String = i._2._1
// val age: String = i._2._1
// })
//关联之后处理数据2--模式匹配
val rdd1: RDD[(String, String, Int)] = innerJoinRDD.map(i => {
case (id: String, (name: String, age: String)) =>
(id, name, age)
})
rdd1.foreach(println)
/**
* left join:以左表为主，如果右表没有数据，就会补一个null
* 数据中右表没有003，所有会补一个null
* Option[String]:没有值就是None
* right join:和left join相反
*/
val leftRDD: RDD[(String, (String, Option[Int]))] = nameRDD.leftOuterJoin(ageRDD)
leftRDD.foreach(println)
//整理数据
val rdd2: RDD[(String, String, Int)] = leftRDD.map({
//匹配关联成功的数据
case (id: String, (name: String, Some(age))) =>
(id, name, age)
//匹配未关联成功的数据
case (id: String, (name: String, None)) =>
(id, name, 0)
})
rdd2.foreach(println)
/**
* full join:两边都可能没有关联上，如果是没关联上，补null
*/
val fullRDD: RDD[(String, (Option[String], Option[Int]))] = nameRDD.fullOuterJoin(ageRDD)
//整理数据
val rdd3: RDD[(String, String, Int)] = fullRDD.map {
case (id: String, (Some(name), Some(age))) =>
(id, name, age)
case (id: String, (None, Some(age))) =>
(id, 0, age)
case (id: String, (Some(name), None)) =>
(id, name, 0)
case (id: String, (None, None)) =>
(id, 0, 0)
}
}
}
- mapValue算子:只对value进行处理，key不变
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Demo12MapValues {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf()
conf.setMaster("local")
.setAppName("mapValues")
val sc: SparkContext = new SparkContext()
//使用map
val ageRDD: RDD[(String, Int)] = sc.makeRDD(List(("001", 23), ("002", 35), ("004", 19)))
val linesRDD: RDD[(String, Int)] = ageRDD.map {
case (id: String, age: Int) =>
(id, age + 1)
}
/**
*mapValue:只对value进行处理，key不变
*/
//使用mapValue
val mapValuesRDD: RDD[(String, Int)] = ageRDD.mapValues(v => v + 1)
}
}
- sort算子:指定一个排序的列，默认是升序,ascending是控制排序方式。
package com.zjl
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Demo13Sort {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf()
conf.setMaster("local")
.setAppName("sort")
val sc: SparkContext = new SparkContext(conf)
val studentsRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\data\\students.txt")
/**
* sortBy:指定一个排序的列，默认是升序
* ascending：控制排序方式
*/
val sortByRDD: RDD[String] = studentsRDD.sortBy(student => {
val age: Int = student.split(",")(2).toInt
age
},false)
val ageRDD: RDD[(String, String)] = sc.makeRDD(List(("001", "23"), ("002", "35"), ("004", "19")))
val dataRDD: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4, 5, 6))
val kvRDD: RDD[(Int, Int)] = dataRDD.map(i => (i, 1))
kvRDD.foreach(println)
/**
* 通过key排序，默认升序
*/
val sortByKeyRDD: RDD[(Int, Int)] = kvRDD.sortByKey()
sortByKeyRDD.foreach(println)
}
}
- .AGG算子
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Demo14Agg {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf()
conf.setMaster("local")
.setAppName("Agg")
val sc: SparkContext = new SparkContext(conf)
val linesRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data\\words.txt")
val wordsRDD: RDD[String] = linesRDD.flatMap(i => i.split(","))
val mapRDD: RDD[(String, Int)] = wordsRDD.map(i => (i, 1))
/**
* reduceByKey:在map端进行预聚合，聚合函数会应用在map端和reduce端（聚合函数会应用在分区内的聚合和分区间的聚合）
*/
val reduceByKeyRDD: RDD[(String, Int)] = mapRDD.reduceByKey((x, y) => x + y)
val aggRDD: RDD[(String, Int)] = mapRDD.aggregateByKey(0)( //初始值
(u: Int, i: Int) => u + i, //分区键的聚合函数（map端的聚合函数）
(u1: Int, u2: Int) => u1 + u2 //分区间的聚合（reduce的聚合函数）
)
aggRDD.foreach(println)
}
}
- 求平均年龄案例：使用aggregateByKey
package com.zjl
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD
object Demo15AggAvgAge {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf()
conf.setMaster("local")
.setAppName("Agg")
val sc: SparkContext = new SparkContext(conf)
val linesRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data\\students.txt")
/**
* 计算班级的平均年龄
*/
//val studentsRDD: RDD[String] = linesRDD.flatMap(i => i.split(","))
val classAndAge: RDD[(String,Double)] = linesRDD.map(student => {
val split: Array[String] = student.split(",")
( split(4),split(2).toDouble)
})
classAndAge.foreach(println)
/**
* 使用groupbykey
*/
val groupByKeyRDD: RDD[(String, Iterable[Double])] = classAndAge.groupByKey()
val avgAgeRDD: RDD[(String,Double)] = groupByKeyRDD.map({
case (clazz: String, age: Iterable[Double]) =>
val avgAge: Double = age.sum / age.size
(clazz, avgAge)
})
/**
* 大数据计算中，最耗时间的就是shuffle，shuffle过程中数据是落地到磁盘中的。
* aggregateByKey:会在map端做预聚合，性能高
* 1.初始值可以有多个
* 2.map端的聚合函数
* 3.reduce端的聚合函数
*/
val avgAge: RDD[(String, (Double, Int))] = classAndAge.aggregateByKey((0.0, 0))(
(u:(Double,Int), age:Double) => (u._1 + age, u._2 + 1),//map端的聚合函数
(u1:(Double,Int), u2:(Double,Int)) => (u1._1 + u2._1, u1._2 + u2._2)//reduce端的聚合函数
)
avgAge.foreach(println)
//计算平均年龄
val avgAgeMapRDD: RDD[(String, Double)] = avgAge.map({
case (clazz: String, (totalAge: Double, sumPerpon: Int)) =>
(clazz, totalAge / sumPerpon)
})
avgAgeMapRDD.foreach(println)
while(true){
}
}
}
- cartesian算子：笛卡尔积，很少使用。
package com.zjl
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Demo16Cartesian {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf()
conf.setMaster("local")
.setAppName("Agg")
val sc: SparkContext = new SparkContext(conf)
val nameRDD: RDD[(String, String)] = sc.makeRDD(List(("001", "张三"), ("002", "李四"), ("003", "王五")))
val ageRDD: RDD[(String, String)] = sc.makeRDD(List(("001", "23"), ("002", "35"), ("004", "19")))
/**
* 笛卡尔积
*/
val cartesianRDD: RDD[((String, String), (String, String))] = nameRDD.cartesian(ageRDD)
}
}
- reduce算子：全局聚合是个action算子。
package com.zjl
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Demo17Reduce {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf()
conf.setMaster("local")
.setAppName("Agg")
val sc: SparkContext = new SparkContext(conf)
val LinesRDD: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4, 5, 6, 7, 8, 9, 0))
/**
* sum:求和，只能用于int或者double或者null类型的求和，action算子
*/
val sumRDD: Double = LinesRDD.sum()
/**
* reduce:全局聚合，action算子
* reduceByKey:通过key进行聚合
*/
val reducrRDD: Int = LinesRDD.reduce((x, y) => (x + y))
}
}
- take算子：取top值，是一个action算子。如果是取第一条数据，使用first。
package com.zjl
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD
object Demo18Take {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf()
conf.setMaster("local")
.setAppName("Agg")
val sc: SparkContext = new SparkContext(conf)
val linesRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data\\words.txt")
/**
* take:取top，是一个action算子
*/
val top100: Array[String] = linesRDD.take(100)
//获取第一条数据
val first: String = linesRDD.first()
}
}
17.案例 ：统计总分大于年级平均分的学生
package com.zjl
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD
object Demo19Student1 {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf()
conf.setMaster("local")
.setAppName("Agg")
val sc: SparkContext = new SparkContext(conf)
val linesRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data\\score.txt")
/**
* 统计总分大于年级平均分的学生
*/
//1、计算学生的总分
val total: RDD[(String, Double)] = linesRDD.map(student => {
val splitRDD: Array[String] = student.split(",")
(splitRDD(0), splitRDD(2).toDouble)
})
total.foreach(println)
val totalScore: RDD[(String, Double)] = total.reduceByKey((x, y) => (x + y))
totalScore.foreach(println)
val totalAllRDD: RDD[Double] = totalScore.map(kv => kv._2)
val avgScore: Double = totalAllRDD.sum() / totalAllRDD.count()
//取出总分大于平均分
val endRDD: RDD[(String, Double)] = totalScore.filter {
case (id: String, score: Double) =>
score > avgScore
}
}
}
3.action算子基本介绍
action算子：在Spark中，action 算子是一类触发 Spark 作业执行的操作。action 算子会导致计算结果被返回到驱
动程序，或者将计算结果保存到外部存储系统。与 transformation 算子不同，action 算子会触发 Spark 作业的执
行，而不仅仅是定义计算逻辑。
- foreach：遍历rdd
- count：统计rdd的行数
- sum：求和
- collect：将rdd转换成scala的集合
object Demo7Action {
//spark代码的入口
def main(args: Array[String]): Unit = {
/**
* spark任务的层级关系：
* application ---> job ---> stages --->task
*/
val conf: SparkConf = {
new SparkConf()
}
conf.setMaster("local")
.setAppName("action")
val sc: SparkContext = new SparkContext(conf)
/**
* action 算子 --触发任务执行，每一个action算子都会触发一个job任务
* 1、foreach：遍历rdd
* 2、saveAsTextFile：保存数据
* 3、count：统计rdd的行数
* 4、sum：求和
* 5、collect：将rdd转换成scala的集合
*/
val studentRDD: RDD[String] = sc.textFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data\\students.txt")
//一次遍历一个数据
studentRDD.foreach(println)
//一次遍历一个分区
studentRDD.foreachPartition((iter:Iterator[String]) => println(iter.toList))
//保存数据
/**
* saveAsTextFile：将数据保存到hdfs中
* 1、输出的目录不能存在
* 2、rdd一个分区对应一个文件
*/
studentRDD.saveAsTextFile("D:\\data\\data\\ideadata\\idea-project\\big_data\\spark\\data")
//统计行数
val count: Long = studentRDD.count()
println(s"studentRDD的行数：$count")
//将rdd的数据拉取到内存中，如果数据量很大会出现内存溢出
val studentArr: Array[String] = studentRDD.collect()
}
}