菜鸟追梦旅行

这个屌丝很懒，什么也没留下！

热门标签

4.大数据技术之SparkCore_第二章:Action算子操作_spark大数据技术与应用第二版课后答案

作者：菜鸟追梦旅行 | 2024-05-14 08:16:51

踩

spark大数据技术与应用第二版课后答案

2.4 Action

2.4.1 reduce(func)案例

1. 作用：通过func函数聚集RDD中的所有元素，先聚合分区内数据，再聚合分区间数据。

2. 需求：创建一个RDD，将所有元素聚合得到结果

（1）创建一个RDD[Int]

scala> val rdd1 = sc.makeRDD(1 to 10,2)

rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[85] at makeRDD at <console>:24

（2）聚合RDD[Int]所有元素

scala> rdd1.reduce(_+_)

res50: Int = 55

（3）创建一个RDD[String]

scala> val rdd2 = sc.makeRDD(Array(("a",1),("a",3),("c",3),("d",5)))

rdd2: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[86] at makeRDD at <console>:24

（4）聚合RDD[String]所有数据

scala> rdd2.reduce((x,y)=>(x._1 + y._1,x._2 + y._2))

res51: (String, Int) = (adca,12)

2.4.2 collect()案例

1. 作用：在驱动程序中，以数组的形式返回数据集的所有元素。

2. 需求：创建一个RDD，并将RDD内容收集到Driver端打印

（1）创建一个RDD

scala> val rdd = sc.parallelize(1 to 10)

rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at <console>:24

（2）将结果收集到Driver端

scala> rdd.collect

res0: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

2.4.3 count()案例

1. 作用：返回RDD中元素的个数

2. 需求：创建一个RDD，统计该RDD的条数

（1）创建一个RDD

scala> val rdd = sc.parallelize(1 to 10)

rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at <console>:24

（2）统计该RDD的条数

scala> rdd.count

res1: Long = 10

2.4.4 first()案例

1. 作用：返回RDD中的第一个元素

2. 需求：创建一个RDD，返回该RDD中的第一个元素

（1）创建一个RDD

scala> val rdd = sc.parallelize(1 to 10)

rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at <console>:24

（2）统计该RDD的条数

scala> rdd.first

res2: Int = 1

2.4.5 take(n)案例

1. 作用：返回一个由RDD的前n个元素组成的数组

2. 需求：创建一个RDD，统计该RDD的条数

（1）创建一个RDD

scala> val rdd = sc.parallelize(Array(2,5,4,6,8,3))

rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[2] at parallelize at <console>:24

（2）统计该RDD的条数

scala> rdd.take(3)

res10: Array[Int] = Array(2, 5, 4)

2.4.6 takeOrdered(n)案例

1. 作用：返回该RDD排序后的前n个元素组成的数组

2. 需求：创建一个RDD，统计该RDD的条数

（1）创建一个RDD

scala> val rdd = sc.parallelize(Array(2,5,4,6,8,3))

rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[2] at parallelize at <console>:24

（2）统计该RDD的条数

scala> rdd.takeOrdered(3)

res18: Array[Int] = Array(2, 3, 4)

2.4.7 aggregate案例

1. 参数：(zeroValue: U)(seqOp: (U, T) ⇒ U, combOp: (U, U) ⇒ U)

2. 作用：aggregate函数将每个分区里面的元素通过seqOp和初始值进行聚合，然后用combine函数将每个分区的结果和初始值(zeroValue)进行combine操作。这个函数最终返回的类型不需要和RDD中元素类型一致。

3. 需求：创建一个RDD，将所有元素相加得到结果

（1）创建一个RDD

scala> var rdd1 = sc.makeRDD(1 to 10,2)

rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[88] at makeRDD at <console>:24

（2）将该RDD所有元素相加得到结果

scala> rdd.aggregate(0)(_+_,_+_)

res22: Int = 55

2.4.8 fold(num)(func)案例

1. 作用：折叠操作，aggregate的简化操作，seqop和combop一样。

2. 需求：创建一个RDD，将所有元素相加得到结果

（1）创建一个RDD

scala> var rdd1 = sc.makeRDD(1 to 10,2)

rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[88] at makeRDD at <console>:24

（2）将该RDD所有元素相加得到结果

scala> rdd.fold(0)(_+_)

res24: Int = 55

2.4.9 saveAsTextFile(path)

作用：将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本

2.4.10 saveAsSequenceFile(path)

作用：将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。

2.4.11 saveAsObjectFile(path)

作用：用于将RDD中的元素序列化成对象，存储到文件中。

2.4.12 countByKey()案例

1. 作用：针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。

2. 需求：创建一个PairRDD，统计每种key的个数

（1）创建一个PairRDD

scala> val rdd = sc.parallelize(List((1,3),(1,2),(1,4),(2,3),(3,6),(3,8)),3)

rdd: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[95] at parallelize at <console>:24

（2）统计每种key的个数

scala> rdd.countByKey

res63: scala.collection.Map[Int,Long] = Map(3 -> 2, 1 -> 3, 2 -> 1)

2.4.13 foreach(func)案例

1. 作用：在数据集的每一个元素上，运行函数func进行更新。

2. 需求：创建一个RDD，对每个元素进行打印

（1）创建一个RDD

scala> var rdd = sc.makeRDD(1 to 5,2)

rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[107] at makeRDD at <console>:24

（2）对该RDD每个元素进行打印

scala> rdd.foreach(println(_))

2.4.14 aggregate算子和aggregateByKey算子

Aggregate算子

scala> import scala.math._

import scala.math._

scala> var rdd1 = sc.parallelize(List("12","34","567","8901"),2)

rdd1: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[0] at parallelize at <console>:24

scala> def fun1(index:Int,iter:Iterator[String]):Iterator[String]={

| iter.toList.map(x => "[partID: "+index+",value:"+x+"]").iterator}

fun1: (index: Int, iter: Iterator[String])Iterator[String]

scala> rdd1.mapPartitionsWithIndex(fun1).collect

res1: Array[String] = Array(

[partID: 0,value:12], [partID: 0,value:34],

[partID: 1,value:567], [partID: 1,value:8901])

scala> rdd1.aggregate("")((x,y)=>math.max(x.length,y.length).toString,(x,y)=>x+y)

res3: String = 42

scala> rdd1.aggregate("")((x,y)=>math.max(x.length,y.length).toString,(x,y)=>x+y)

res4: String = 24

分析：

第一个分区：“12”，“34”

第一次比较：“”，“12”=2.toString ==》 “2”

第二次比较：“2”，“34”=2.toString ==》 “2”

第二个分区：“567”，“8901”

第一次比较：“”，“567”=3.toString ==》“3”

第二次比较：“3”，“8901”=4.toString ==》 “4”

“24”或者“42”

scala> var rdd1 = sc.parallelize(List("12","23","345",""),2)

rdd1: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[2] at parallelize at <console>:24

scala> rdd1.mapPartitionsWithIndex(fun1).collect

res6: Array[String] = Array([partID: 0,value:12], [partID: 0,value:23], [partID: 1,value:345], [partID: 1,value:])

scala> rdd1.aggregate("")((x,y)=>math.min(x.length,y.length).toString,(x,y)=>x+y)

res7: String = 10

scala> rdd1.aggregate("")((x,y)=>math.min(x.length,y.length).toString,(x,y)=>x+y)

res9: String = 01

分析：

第一个分区：“12”，“23”

第一次比较：“”，“12”=0.toString ==》 “0”

第二次比较：“0”，“23”=1.toString ==》 “1”

第二个分区：“345”，“”

第一次比较：“”，“345”=0.toString ==》“0”

第二次比较：“0”，“”=0.toString ==》 “0”

“10”或者“01”

AggregateByKey算子

scala> import scala.math._

import scala.math._

scala> var rdd1 = sc.parallelize(List(("Tom",20),("Tom",25),("Plus",2),("Plus",18),("Make",30),("Make",20),("Tom",10)),2)

rdd1: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[10] at parallelize at <console>:24

scala> def fun2(index:Int,iter:Iterator[(String,Int)]):Iterator[String]={

| iter.toList.map(x => "[partId: "+index+",value: "+x+"]").iterator}

fun2: (index: Int, iter: Iterator[(String, Int)])Iterator[String]

scala> rdd1.mapPartitionsWithIndex(fun2)

res18: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[8] at mapPartitionsWithIndex at <console>:29

scala> rdd1.mapPartitionsWithIndex(fun2).collect

res20: Array[String] = Array(

[partId: 0,value: (Tom,20)], [partId: 0,value: (Tom,25)], [partId: 0,value: (Plus,2)], [partId: 1,value: (Plus,18)], [partId: 1,value: (Make,30)], [partId: 1,value: (Make,20)], [partId: 1,value: (Tom,10)])

scala> rdd1.aggregateByKey(0)(math.max(_,_),_+_)

res21: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[12] at aggregateByKey at <console>:27

scala> var rdd2 = rdd1.aggregateByKey(0)(math.max(_,_),_+_)

rdd2: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[13] at aggregateByKey at <console>:26

scala> rdd2.collect

res22: Array[(String, Int)] = Array((Tom,35), (Plus,20), (Make,30))

第一个分区：(Tom,20)，(Tom,25)，(Plus,2)

max：Tom：25，Plus：2

第二个分区：(Plus,18)， (Make,30)，(Make,20)，(Tom,10)

max:plus:18,Make:30,Tom:10

相加：Tom：35，Plus:20,Make:30

scala> var rdd2 = rdd1.aggregateByKey(0)(_+_,_+_)

rdd2: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[14] at aggregateByKey at <console>:26

scala> rdd2.collect

res23: Array[(String, Int)] = Array((Tom,55), (Plus,20), (Make,50))

2.5 RDD中的函数传递(自定义算子,注意要序列化)

在实际开发中我们往往需要自己定义一些对于RDD的操作，那么此时需要主要的是，初始化工作是在Driver端进行的，而实际运行程序是在Executor端进行的，这就涉及到了跨进程通信，是需要序列化的。下面我们看几个例子：

2.5.1 传递一个方法

1．创建一个类

class Search(query:String){

//过滤出包含字符串的数据

def isMatch(s: String): Boolean = {

s.contains(query)

}

//过滤出包含字符串的RDD

def getMatch1 (rdd: RDD[String]): RDD[String] = {

rdd.filter(isMatch)

}

//过滤出包含字符串的RDD

def getMatche2(rdd: RDD[String]): RDD[String] = {

rdd.filter(x => x.contains(query))

}

2．创建Spark主程序

object SeriTest {

def main(args: Array[String]): Unit = {

//1.初始化配置信息及SparkContext

val sparkConf: SparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]")

val sc = new SparkContext(sparkConf)

//2.创建一个RDD

val rdd: RDD[String] = sc.parallelize(Array("hadoop", "spark", "hive", "itstar"))

//3.创建一个Search对象

val search = new Search("spark")

//4.运用第一个过滤函数并打印结果

val match1: RDD[String] = search.getMatche1(rdd)

match1.collect().foreach(println)

}

3．运行程序

Exception in thread "main" org.apache.spark.SparkException: Task not serializable

at org.apache.spark.util.ClosureCleaner$.ensureSerializable(ClosureCleaner.scala:298)

at org.apache.spark.util.ClosureCleaner$.org$apache$spark$util$ClosureCleaner$$clean(ClosureCleaner.scala:288)

at org.apache.spark.util.ClosureCleaner$.clean(ClosureCleaner.scala:108)

at org.apache.spark.SparkContext.clean(SparkContext.scala:2101)

at org.apache.spark.rdd.RDD$$anonfun$filter$1.apply(RDD.scala:387)

at org.apache.spark.rdd.RDD$$anonfun$filter$1.apply(RDD.scala:386)

at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:151)

at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:112)

at org.apache.spark.rdd.RDD.withScope(RDD.scala:362)

at org.apache.spark.rdd.RDD.filter(RDD.scala:386)

at com.itstar.Search.getMatche1(SeriTest.scala:39)

at com.itstar.SeriTest$.main(SeriTest.scala:18)

at com.itstar.SeriTest.main(SeriTest.scala)

Caused by: java.io.NotSerializableException: com.itstar.Search

4．问题说明

//过滤出包含字符串的RDD

def getMatch1 (rdd: RDD[String]): RDD[String] = {

rdd.filter(isMatch)

}

在这个方法中所调用的方法isMatch()是定义在Search这个类中的，实际上调用的是this. isMatch()，this表示Search这个类的对象，程序在运行过程中需要将Search对象序列化以后传递到Executor端。

5．解决方案

使类继承scala.Serializable即可。

class Search() extends Serializable{...}

2.5.2 传递一个属性

1．创建Spark主程序

object TransmitTest {

def main(args: Array[String]): Unit = {

//1.初始化配置信息及SparkContext

val sparkConf: SparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]")

val sc = new SparkContext(sparkConf)

//2.创建一个RDD

val rdd: RDD[String] = sc.parallelize(Array("hadoop", "spark", "hive", "itstar"))

//3.创建一个Search对象

val search = new Search(“spark”)

//4.运用第一个过滤函数并打印结果

val match1: RDD[String] = search.getMatche2(rdd)

match1.collect().foreach(println)

}

2．运行程序