人工智能图像识别Spark Core3

Spark Core3

Spark-Core编程（三）

1.key-value类型：

23. sortByKey

函数签名

def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length): RDD(K, V)

函数说明

在一个(K,V)的 RDD 上调用，K 必须实现 Ordered 接口(特质)，返回一个按照 key 进行排序

val dataRDD1 = sc.makeRDD(List(("a",1),("b",2),("c",3)))

val sortRDD1: RDD(String, Int) = dataRDD1.sortByKey(true)

val sortRDD2: RDD(String, Int) = dataRDD1.sortByKey(false)

24. join

函数签名

def joinW(other: RDD(K, W)): RDD(K, (V, W))

函数说明

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

(K,(V,W))的 RDD

val rdd: RDD(Int, String) = sc.makeRDD(Array((1, "a"), (2, "b"), (3, "c")))

val rdd1: RDD(Int, Int) = sc.makeRDD(Array((1, 4), (2, 5), (3, 6)))

rdd.join(rdd1).collect().foreach(println)

25. leftOuterJoin

函数签名

def leftOuterJoinW(other: RDD(K, W)): RDD(K, (V, Option\[W))]

函数说明

类似于 SQL 语句的左外连接

val dataRDD1 = sc.makeRDD(List(("a",1),("b",2),("c",4)))

val dataRDD2 = sc.makeRDD(List(("a",1),("b",2),("c",3)))

val rdd: RDD(String, (Int, Option\[Int))] = dataRDD1.leftOuterJoin(dataRDD2)

26. cogroup

函数签名

def cogroupW(other: RDD(K, W)): RDD(K, (Iterable\[V, IterableW))]

函数说明

在类型为(K,V)和(K,W)的 RDD 上调用，返回一个(K,(Iterable<V>,Iterable<W>))类型的 RDD

val dataRDD1 = sc.makeRDD(List(("a",1),("a",2),("c",3)))

val dataRDD2 = sc.makeRDD(List(("a",1),("c",2),("c",3)))

val value: RDD(String, (Iterable\[Int, IterableInt))] =

dataRDD1.cogroup(dataRDD2)

2.RDD行动算子：

行动算子就是会触发action的算子，触发action的含义就是真正的计算数据。

1. reduce

函数签名

def reduce(f: (T, T) => T): T

函数说明

聚集 RDD 中的所有元素，先聚合分区内数据，再聚合分区间数据

val rdd: RDDInt = sc.makeRDD(List(1,2,3,4))

val reduceResult: Int = rdd.reduce(+)

println(reduceResult)

2. collect

函数签名

def collect(): ArrayT

函数说明

在驱动程序中，以数组 Array 的形式返回数据集的所有元素

3. foreach

函数签名

def foreach(f: T => Unit): Unit = withScope {

val cleanF = sc.clean(f)

sc.runJob(this, (iter: IteratorT) => iter.foreach(cleanF))

}

函数说明

分布式遍历 RDD 中的每一个元素，调用指定函数

val rdd: RDDInt = sc.makeRDD(List(1,2,3,4))

rdd.collect().foreach(println)

4. count

函数签名

def count(): Long

函数说明

返回 RDD 中元素的个数

val rdd: RDDInt = sc.makeRDD(List(1,2,3,4))

val countResult: Long = rdd.count()

println(countResult)

5. first

函数签名

def first(): T

函数说明

返回 RDD 中的第一个元素

val rdd: RDDInt = sc.makeRDD(List(1,2,3,4))

val firstResult: Int = rdd.first()

println(firstResult)

6. take

函数签名

def take(num: Int): ArrayT

函数说明

返回一个由 RDD 的前 n 个元素组成的数组

val rdd: RDDInt = sc.makeRDD(List(1,2,3,4))

val takeResult: ArrayInt = rdd.take(2)

takeResult.foreach(println)

7. takeOrdered

函数签名

def takeOrdered(num: Int)(implicit ord: OrderingT): ArrayT

函数说明

返回该 RDD 排序后的前 n 个元素组成的数组

val rdd: RDDInt = sc.makeRDD(List(1,3,2,4))

val result: ArrayInt = rdd.takeOrdered(2)

result.foreach(println)

8. aggregate

函数签名

def aggregateU: ClassTag(zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U

函数说明

分区的数据通过初始值和分区内的数据进行聚合，然后再和初始值进行分区间的数据聚合

val rdd: RDDInt = sc.makeRDD(List(1,2,3,4),8)

// 将该 RDD 所有元素相加得到结果

val result1: Int = rdd.aggregate(0)(+, +)

val result2: Int = rdd.aggregate(10)(+,+)

println(result1)

println("**********")

9. fold

函数签名

def fold(zeroValue: T)(op: (T, T) => T): T

函数说明

折叠操作，aggregate 的简化版操作

val rdd: RDDInt = sc.makeRDD(List(1, 2, 3, 4))

val foldResult: Int = rdd.fold(0)(+)

println(foldResult)

10. countByKey

函数签名

def countByKey(): MapK, Long

函数说明

统计每种 key 的个数

val rdd: RDD(Int, String) = sc.makeRDD(List((1, "a"), (1, "a"), (1, "a"), (2,"b"), (3, "c"), (3, "c")))

val result: collection.MapInt, Long = rdd.countByKey()

print(result)

11. save 相关算子

函数签名

def saveAsTextFile(path: String): Unit

def saveAsObjectFile(path: String): Unit

def saveAsSequenceFile(

path: String,

codec: OptionClass\[_ \<: CompressionCodec] = None): Unit //了解即可

函数说明

将数据保存到不同格式的文件中

val rdd: RDDInt = sc.makeRDD(List(1, 2, 3, 4))

// 保存成 Text 文件

rdd.saveAsTextFile("Spark-core/output/output")

// 序列化成对象保存到文件

rdd.saveAsObjectFile("Spark-core/output/output1")

3.累加器

实现原理

累加器用来把 Executor 端变量信息聚合到 Driver 端。在 Driver 程序中定义的变量，在

Executor 端的每个 Task 都会得到这个变量的一份新的副本，每个 task 更新这些副本的值后，传回 Driver 端进行 merge。

val rdd = sparkContext.makeRDD(List(1,2,3,4,5))

// 声明累加器

var sum = sparkContext.longAccumulator("sum");

rdd.foreach(

num => {

// 使用累加器

sum.add(num)

}

)

// 获取累加器的值

println("sum = " + sum.value)

自定义累加器实现wordcount：

创建自定义累加器：

class WordCountAccumulator extends AccumulatorV2String,mutable.Map\[String,Long] {

var map:mutable.MapString,Long = mutable.Map()

override def isZero: Boolean = map.isEmpty

override def copy(): AccumulatorV2String, mutable.Map\[String,Long] = new WordCountAccumulator

override def reset(): Unit = map.clear()

override def add(v: String): Unit = {

map(v) = map.getOrElse(v,0L)+1L

}

override def merge(other: AccumulatorV2String, mutable.Map\[String,Long

]): Unit = {

val map1 = map

val map2 = other.value

map = map1.foldLeft(map2)(

(innerMap,kv)=>{

innerMap(kv._1) = innerMap.getOrElse(kv._1,0L)+kv._2

innerMap

}

)

}

override def value: mutable.MapString,Long = map

}

调用自定义累加器：

val rdd = sparkContext.makeRDD(

List("spark","scala","spark hadoop","hadoop")

)

val acc = new WordCountAccumulator

sparkContext.register(acc)

rdd.flatMap(_.split(" ")).foreach(

word=>acc.add(word)

)

println(acc.value)

4.广播变量

实现原理

广播变量用来高效分发较大的对象。向所有工作节点发送一个较大的只读值，以供一个

或多个 Spark 操作使用。比如，如果你的应用需要向所有节点发送一个较大的只读查询表，

广播变量用起来都很顺手。在多个并行操作中使用同一个变量，但是 Spark 会为每个任务

分别发送。

val rdd1 = sparkContext.makeRDD(List( ("a",1), ("b", 2), ("c", 3), ("d", 4) ),4)

val list = List( ("a",4), ("b", 5), ("c", 6), ("d", 7))

val broadcast :BroadcastList\[(String,Int)] = sparkContext.broadcast(list)

val resultRDD :RDD(String,(Int,Int)) = rdd1.map{

case (key,num)=> {

var num2 = 0

for((k,v)<-broadcast.value){

if(k == key) {

num2 = v

}

}

(key,(num,num2))

}

}

resultRDD.collect().foreach(println)

sparkContext.stop()

}