Spark记录

Spark是一个用来实现快速而通用的集群计算的平台
=> Scala 中定义内联函数的简写方法
初始化SparkContext
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.SparkContext._
val conf = new SparkConf().setMaster(“local”).setAppName(“My App”)
val sc = new SparkContext(conf)

val lines = sc.textFile(“README.md”) // 创建一个叫lines的RDD
val pythonLines = lines.filter(line => line.contains(“Python”))
pythonLines.first()

// 创建一个Scala版本的Spark Context
val conf = new SparkConf().setAppName(“wordCount”)
val sc = new SparkContext(conf)
// 读取我们的输入数据
val input = sc.textFile(inputFile)
// 把它切分成一个个单词
val words = input.flatMap(line => line.split(" "))
// 转换为键值对并计数
val counts = words.map(word => (word, 1)).reduceByKey{case (x, y) => x + y}
// 将统计出来的单词总数存入一个文本文件，引发求值
counts.saveAsTextFile(outputFile)

弹性分布式数据集 RDD
用户可以使用两种方法创建RDD：读取一个外部数据集，或在驱动器程序里分发驱动器程序中的对象集合（比如list 和set）
RDD 支持两种类型的操作： 转化操作（transformation） 和行动操作
转化操作会由一个RDD 生成一个新的RDD
行动操作会对RDD 计算出一个结果
转化操作和行动操作的区别在于Spark 计算RDD 的方式不同，Spark 只会惰性计算这些RDD。只有在一个行动操作中用到时，才会真正计算。
RDD.persist() 让Spark 把这个RDD 缓存下来

在驱动器程序里分发驱动器程序中的对象集合：val lines = sc.parallelize(List(“pandas”, “i like pandas”))

用Scala 实现filter() 转化操作
val inputRDD = sc.textFile(“log.txt”)
val errorsRDD = inputRDD.filter(line => line.contains(“error”))

Scala 版计算RDD 中各值的平方
val input = sc.parallelize(List(1, 2, 3, 4))
val result = input.map(x => x * x)
println(result.collect().mkString(","))

Scala 中的flatMap() 将行数据切分为单词
val lines = sc.parallelize(List(“hello world”, “hi”))
val words = lines.flatMap(line => line.split(" “))
words.first() // 返回"hello”

对一个数据为{1, 2, 3, 3}的RDD进行基本的RDD转化操作
map() 将函数应用于RDD 中的每个元素，将返回值构成新的RDD rdd.map(x => x + 1) {2, 3, 4, 4}
flatMap() 将函数应用于RDD 中的每个元素，将返回的迭代器的所有内容构成新的RDD。通常用来切分单词
rdd.flatMap(x => x.to(3)) {1, 2, 3, 2, 3, 3, 3}
filter() 返回一个由通过传给filter()的函数的元素组成的RDD
rdd.filter(x => x != 1) {2, 3, 3}
distinct() 去重 rdd.distinct() {1, 2, 3}

对数据分别为{1, 2, 3}和{3, 4, 5}的RDD进行针对两个RDD的转化操作
union() 生成一个包含两个RDD 中所有元素的RDD
rdd.union(other) {1, 2, 3, 3, 4, 5}
intersection() 求两个RDD共同的元素的RDD rdd.intersection(other) {3}
subtract() 移除一个RDD 中的内容 rdd.subtract(other) {1, 2}
cartesian() 与另一个RDD 的笛卡儿积 rdd.cartesian(other)

行动操作：会用到基本RDD 上最常见的行动操作reduce()，可以很方便地计算出RDD中所有元素的总和、元素的个数，以及其他类型的聚合操作
对一个数据为{1, 2, 3, 3}的RDD进行基本的RDD行动操作
collect() 返回RDD 中的所有元素 rdd.collect() {1, 2, 3, 3}
count() RDD 中的元素个数 rdd.count() 4
countByValue() 各元素在RDD 中出现的次数rdd.countByValue() {(1, 1),(2, 1),(3, 2)}
take(num) 从RDD 中返回num 个元素rdd.take(2) {1, 2}
top(num) 从RDD 中返回最前面的num个元素 rdd.top(2) {3, 3}
reduce(func) 并行整合RDD 中所有数据（例如sum） rdd.reduce((x, y) => x + y) 9
foreach(func) 对RDD 中的每个元素使用给定的函数 rdd.foreach(func)

在Scala 中使用persist()
val result = input.map(x => x * x)
result.persist(StorageLevel.DISK_ONLY)
println(result.count())
println(result.collect().mkString(","))

键值对RDD 是Spark 中许多操作所需要的常见数据类型（pair RDD）
在Scala 中使用第一个单词作为键创建出一个pair RDD
val pairs = lines.map(x => (x.split(" ")(0), x))
pair RDD 中包含二元组，所以需要传递的函数应当操作二元组而不是独立的元素

Pair RDD的转化操作（以键值对集合{(1, 2), (3, 4), (3, 6)}为例）
reduceByKey(func) 合并具有相同键的值 rdd.reduceByKey((x, y) => x + y)
{(1,2), (3,10)}
groupByKey() 对具有相同键的值进行分组 rdd.groupByKey()
{(1,[2]),(3, [4,6])}
mapValues(func) 对pair RDD 中的每个值应用一个函数而不改变键 rdd.mapValues(x => x+1)
{(1,3), (3,5), (3,7)}
flatMapValues(func) 对pair RDD 中的每个值应用一个返回迭代器的函数，然后对返回的每个元素都生成一个
对应原键的键值对记录。通常用于符号化
rdd.flatMapValues(x => (x to 5))
{(1,2), (1,3), (1,4), (1,5), (3,4), (3,5)}
keys() 返回一个仅包含键的RDD rdd.keys() {1, 3,3}
values() 返回一个仅包含值的RDD rdd.values() {2, 4,6}
sortByKey() 返回一个根据键排序的RDD rdd.sortByKey() {(1,2), (3,4), (3,6)}

针对两个pair RDD的转化操作（rdd = {(1, 2), (3, 4), (3, 6)}other = {(3, 9)}）
subtractByKey 删掉RDD 中键与otherRDD中的键相同的元素
rdd.subtractByKey(other) {(1, 2)}
join 对两个RDD 进行内连接rdd.join(other) {(3, (4, 9)), (3,(6, 9))}
rightOuterJoin 对两个RDD 进行连接操作，确保第一个RDD 的键必须存在（右外连接）
rdd.rightOuterJoin(other) {(3,(Some(4),9)),(3,(Some(6),9))}
leftOuterJoin 对两个RDD 进行连接操作，确保第二个RDD 的键必须存在（左外连接）
rdd.leftOuterJoin(other) {(1,(2,None)), (3,(4,Some(9))), (3,(6,Some(9)))}
cogroup 将两个RDD 中拥有相同键的数据分组到一起
rdd.cogroup(other) {(1,([2],[])), (3,([4, 6],[9]))}

用Scala 对第二个元素进行筛选
pairs.filter{case (key, value) => value.length < 20}

用Scala 实现单词计数
val input = sc.textFile(“s3://…”)
val words = input.flatMap(x => x.split(" "))
val result = words.map(x => (x, 1)).reduceByKey((x, y) => x + y)

Pair RDD的行动操作（以键值对集合{(1, 2), (3, 4), (3, 6)}为例）
countByKey() 对每个键对应的元素分别计数rdd.countByKey() {(1, 1), (3, 2)}
collectAsMap() 将结果以映射表的形式返回，以便查询rdd.collectAsMap() Map{(1, 2), (3,4), (3, 6)}
lookup(key) 返回给定键对应的所有值rdd.lookup(3) [4, 6]