Spark学习笔记3——RDD(下)

笔记摘抄自 [美] Holden Karau 等著的《Spark快速大数据分析》

向Spark传递函数

大部分 Spark 的转化操作和一部分行动操作,都需要传递函数后进行计算。如何传递函数下文将用 Java 展示。

Java 向 Spark 传递函数需要实现 Spark 的 org.apache.spark.api.java.function 包中的接口。一些基本的接口如下表:

函数名 实现的方法 用途
Function<T, R> R call(T) 接收一个输入值并返回一个输出值,用于类似map() 和
filter() 等操作中
Function2<T1, T2, R> R call(T1, T2) 接收两个输入值并返回一个输出值,用于类似aggregate()
和fold() 等操作中
FlatMapFunction<T, R> Iterable call(T) 接收一个输入值并返回任意个输出,用于类似flatMap()
这样的操作中

通过匿名内部类

见上篇笔记例程。

通过具名类传递

class ContainsError implements Function<String, Boolean>() {
public Boolean call(String x) { return x.contains("error"); }
}
...
RDD<String> errors = lines.filter(new ContainsError());
  • 使用具名类在程序组织比较庞大是显得比较清晰
  • 可以使用构造函数如“通过带参数的 Java 函数类传递”中所示

通过带参数的 Java 函数类传递

例程

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function; import java.util.List; public class Contains implements Function<String, Boolean> {
private String query; public Contains(String query) {
this.query = query;
} public Boolean call(String x) {
return x.contains(query);
} public static void main(String[] args) {
SparkConf sc = new SparkConf().setAppName("Contains");
JavaSparkContext javaSparkContext = new JavaSparkContext(sc);
JavaRDD<String> log = javaSparkContext.textFile(args[0]); JavaRDD<String> content = log.filter(new Contains(args[1])); List<String> contentList = content.collect();
for (String output : contentList) {
System.out.println(output);
}
javaSparkContext.stop();
}
}

测试文本 test.txt

this is a test
this is a simple test
this is a simple test about RDD
let us check it out

测试结果

[root@server1 spark-2.4.4-bin-hadoop2.7]# bin/spark-submit --class Contains ~/RDDFuncNamedClass.jar ~/test.txt RDD
...
19/09/16 15:06:50 INFO DAGScheduler: Job 0 finished: collect at Contains.java:24, took 0.445049 s
this is a simple test about RDD
...

通过 lambda 表达式传递(仅限于 Java 8 及以上)

例程

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext; import java.util.List; public class LambdaTest {
public static void main(final String[] args) {
SparkConf sc = new SparkConf().setAppName("Contains");
JavaSparkContext javaSparkContext = new JavaSparkContext(sc);
JavaRDD<String> log = javaSparkContext.textFile(args[0]); JavaRDD<String> content = log.filter(s -> s.contains(args[1])); List<String> contentList = content.collect();
for (String output : contentList) {
System.out.println(output);
}
javaSparkContext.stop();
}
}

测试文本

使用上文同一个文本

运行结果

[root@server1 spark-2.4.4-bin-hadoop2.7]# bin/spark-submit --class Contains ~/RDDFuncNamedClass.jar ~/test.txt check
...
19/09/16 15:27:10 INFO DAGScheduler: Job 0 finished: collect at Contains.java:24, took 0.440515 s
let us check it out
...

常见的转化操作和行动操作

Spark 中有不同类型的 RDD,不同的 RDD 可以支持不同的操作。

除了基本的RDD外,还有数字类型的 RDD 支持统计型函数操作、键值对形式的 RDD 支持聚合数据的键值对操作等等。

基本RDD

针对各个元素的转化操作

为了方便,代码在 pyspark 中展示:

# map()
# map() 的返回值类型不需要和输入类型一样
>>> nums = sc.parallelize([1, 2, 3, 4])
>>> squared = nums.map(lambda x: x * x).collect()
>>> for num in squared:
... print "%i " % (num)
...
1
4
9
16 # flatMap()
# 给flatMap() 的函数被分别应用到了输入RDD 的每个元素上。
# 返回的是一个返回值序列的迭代器。
#
>>> lines = sc.parallelize(["hello world", "hi"])
>>> words = lines.flatMap(lambda line: line.split(" "))
>>> words.first()
'hello'

map() 和 flatmap() 区别如下:

伪集合操作

RDD 不算是严格意义上的集合,但是一些类似集合的属性让它能够支持许多集合操作,下图展示了常见的集合操作:

此外,RDD 还支持笛卡尔积的操作:

以下对基本 RDD 的转化操作进行梳理:

  • 单个 RDD {1,2,3,3} 的转化操作
函数名 目的 示例 结果
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}
sample(withReplacement, fraction, [seed]) 对RDD 采样,以及是否替换 rdd.sample(false, 0.5) 非确定的
  • 两个 RDD {1,2,3},{3,4,5}的 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) {(1, 3), (1, 4), ...
(3, 5)}

行动操作

reduce() 与 reduceByKey()

例程[1]

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext; import scala.Tuple2; import java.util.Arrays;
import java.util.List; public class SimpleReduce {
public static void main(String[] args) {
SparkConf sc = new SparkConf().setAppName("Contains");
JavaSparkContext javaSparkContext = new JavaSparkContext(sc);
List<Integer> data = Arrays.asList(1, 2, 3, 4, 5);
JavaRDD<Integer> originRDD = javaSparkContext.parallelize(data); Integer sum = originRDD.reduce((a, b) -> a + b);
System.out.println(sum); //reduceByKey,按照相同的key进行reduce操作
List<String> list = Arrays.asList("key1", "key1", "key2", "key2", "key3");
JavaRDD<String> stringRDD = javaSparkContext.parallelize(list);
//转为key-value形式
JavaPairRDD<String, Integer> pairRDD = stringRDD.mapToPair(k -> new Tuple2<>(k, 1));
List list1 = pairRDD.reduceByKey((x, y) -> x + y).collect();
System.out.println(list1);
} }

运行结果

...
19/09/17 17:08:37 INFO DAGScheduler: Job 0 finished: reduce at SimpleReduce.java:21, took 0.480038 s
15
...
19/09/17 17:08:38 INFO DAGScheduler: Job 1 finished: collect at SimpleReduce.java:29, took 0.237601 s
[(key3,1), (key1,2), (key2,2)]
...

aggregate()[2]

例程

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function2; import java.io.Serializable;
import java.util.Arrays;
import java.util.List; public class AvgCount implements Serializable {
private AvgCount(int total, int num) {
this.total = total;
this.num = num;
}
private int total;
private int num;
private double avg() {
return total / (double) num;
} public static void main(String[] args) {
SparkConf sc = new SparkConf().setAppName("Contains");
JavaSparkContext javaSparkContext = new JavaSparkContext(sc);
List<Integer> data = Arrays.asList(1, 2, 3, 4, 5);
JavaRDD<Integer> rdd = javaSparkContext.parallelize(data);
AvgCount initial = new AvgCount(0, 0);
Function2<AvgCount, Integer, AvgCount> addAndCount =
new Function2<AvgCount, Integer, AvgCount>() {
public AvgCount call(AvgCount a, Integer x) {
a.total += x;
a.num += 1;
return a;
}
};
Function2<AvgCount, AvgCount, AvgCount> combine =
new Function2<AvgCount, AvgCount, AvgCount>() {
public AvgCount call(AvgCount a, AvgCount b) {
a.total += b.total;
a.num += b.num;
return a;
}
};
AvgCount result = rdd.aggregate(initial, addAndCount, combine);
System.out.println(result.avg());
}
}

运行结果

[root@server1 spark-2.4.4-bin-hadoop2.7]# bin/spark-submit --class AvgCount ~/Spark_RDD_Aggregate.jar
...
19/09/18 15:28:19 INFO DAGScheduler: Job 0 finished: aggregate at AvgCount.java:43, took 0.517385 s
3.0
...

常用的行动操作整理

函数名 目的 示例 结果
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}
takeOrdered(num)
(ordering)
从RDD 中按照提供的顺序返
回最前面的num 个元素
rdd.takeOrdered(2)(myOrdering) {3, 3}
takeSample(withReplace
ment, num, [seed])
从RDD 中返回任意一些元素 rdd.takeSample(false, 1) 非确定的
reduce(func) 并行整合RDD 中所有数据
(例如sum)
rdd.reduce((x, y) => x + y) 9
fold(zero)(func) 和reduce() 一样, 但是需要
提供初始值
rdd.fold(0)((x, y) => x + y) 9
aggregate(zeroValue)
(seqOp, combOp)
和reduce() 相似, 但是通常
返回不同类型的函数
rdd.aggregate((0, 0))
((x, y) =>
(x._1 + y, x._2 + 1),
(x, y) =>
(x._1 + y._1, x._2 + y._2))
(9,4)
foreach(func) 对RDD 中的每个元素使用给
定的函数
rdd.foreach(func)

不同 RDD 的类型转换

Spark 中有些函数只能作用于特定类型的 RDD。例如 mean() 和 variance() 只能处理数值 RDD,join() 只能用于处理键值对 RDD。在 Scala 和 Java 中都没有与之对应的标准 RDD 类,故使用这些函数时必须要确保获得了正确的专用 RDD 类。(Scala 为隐式转换)

下表为 Java 中针对专门类型的函数接口:

函数名 等价函数 用途
DoubleFlatMapFunction Function<T, Iterable> 用于flatMapToDouble,以
生成DoubleRDD
DoubleFunction Function<T, Double> 用于mapToDouble,以生成
DoubleRDD
PairFlatMapFunction<T, K, V> Function<T, Iterable<Tuple2<K, V>>> 用于flatMapToPair,以生
成PairRDD<K, V>
PairFunction<T, K, V> Function<T, Tuple2<K, V>> 用于mapToPair, 以生成
PairRDD<K, V>

例程

以 DoubleFunction 为例:

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaDoubleRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.DoubleFunction; import java.util.Arrays; public class DoubleRDD {
public static void main(String[] args) {
SparkConf sparkConf=new SparkConf().setAppName("DoubleRDD");
JavaSparkContext javaSparkContext=new JavaSparkContext(sparkConf);
JavaRDD<Integer> rdd = javaSparkContext.parallelize(Arrays.asList(1, 2, 3, 4));
JavaDoubleRDD result = rdd.mapToDouble(
new DoubleFunction<Integer>() {
public double call(Integer x) {
return (double) x * x;
}
});
System.out.println(result.mean());
}
}

运行结果

[root@server1 spark-2.4.4-bin-hadoop2.7]# bin/spark-submit --class DoubleRDD ~/Spark_RDD_DoubleRDD.jar
...
19/09/18 16:09:38 INFO DAGScheduler: Job 0 finished: mean at DoubleRDD.java:20, took 0.500705 s
7.5
...

持久化

为了避免多次计算同一个 RDD,我们常常对数据进行持久化处理。具体操作可以参见上一节例程。

Tips:

  • 在Scala 和Java 中,默认情况下 persist() 会把数据以序列化的形式缓存在JVM 的堆空间中
  • 在Python 中,我们会始终序列化要持久化存储的数据,所以持久化级别默认值就是以序列化后的对象存储在JVM 堆空间中
  • 当我们把数据写到磁盘或者堆外存储上时,也总是使用序列化后的数据
  • 缓存的数据太多,内存中放不下,Spark 会自动利用最近最少使用(LRU)的缓存策略把最老的分区从内存中移除
  • unpersist() 可以手动把持久化的RDD 从缓存中移除

持久化级别

级  别 使用的
空间
CPU
时间
是否在
内存中
是否在
磁盘上
备注
MEMORY_ONLY
MEMORY_ONLY_SER
MEMORY_AND_DISK 中等 部分 部分 如果数据在内存中放不下,则溢写到磁盘上
MEMORY_AND_DISK_SER 部分 部分 如果数据在内存中放不下,则溢写到磁盘上。在内存中存放序列化后的数据
DISK_ONLY

P.s.

可以通过在存储级别的末尾加上“_2”来把持久化数据存为两份



  1. 摘自天涯泪小武 的博客 ↩︎

  2. fold() 和 reduce() 不同的是,需要再加上一个“初始值”来作为每个分区第一次调用时的结果;aggregate() 和 前两者不同的是,返回值类型可以和 RDD 的类型不一致 ↩︎

Spark学习笔记3——RDD(下)的更多相关文章

  1. Spark学习笔记2——RDD(上)

    目录 Spark学习笔记2--RDD(上) RDD是什么? 例子 创建 RDD 并行化方式 读取外部数据集方式 RDD 操作 转化操作 行动操作 惰性求值 Spark学习笔记2--RDD(上) 笔记摘 ...

  2. Spark学习笔记之RDD中的Transformation和Action函数

    总算可以开始写第一篇技术博客了,就从学习Spark开始吧.之前阅读了很多关于Spark的文章,对Spark的工作机制及编程模型有了一定了解,下面把Spark中对RDD的常用操作函数做一下总结,以pys ...

  3. spark学习笔记总结-spark入门资料精化

    Spark学习笔记 Spark简介 spark 可以很容易和yarn结合,直接调用HDFS.Hbase上面的数据,和hadoop结合.配置很容易. spark发展迅猛,框架比hadoop更加灵活实用. ...

  4. Spark学习笔记-GraphX-1

    Spark学习笔记-GraphX-1 标签: SparkGraphGraphX图计算 2014-09-29 13:04 2339人阅读 评论(0) 收藏 举报  分类: Spark(8)  版权声明: ...

  5. Spark学习笔记1——第一个Spark程序:单词数统计

    Spark学习笔记1--第一个Spark程序:单词数统计 笔记摘抄自 [美] Holden Karau 等著的<Spark快速大数据分析> 添加依赖 通过 Maven 添加 Spark-c ...

  6. Spark学习笔记之SparkRDD

    Spark学习笔记之SparkRDD 一.   基本概念 RDD(resilient distributed datasets)弹性分布式数据集. 来自于两方面 ①   内存集合和外部存储系统 ②   ...

  7. Spark学习笔记2(spark所需环境配置

    Spark学习笔记2 配置spark所需环境 1.首先先把本地的maven的压缩包解压到本地文件夹中,安装好本地的maven客户端程序,版本没有什么要求 不需要最新版的maven客户端. 解压完成之后 ...

  8. Spark学习笔记3(IDEA编写scala代码并打包上传集群运行)

    Spark学习笔记3 IDEA编写scala代码并打包上传集群运行 我们在IDEA上的maven项目已经搭建完成了,现在可以写一个简单的spark代码并且打成jar包 上传至集群,来检验一下我们的sp ...

  9. Spark学习笔记0——简单了解和技术架构

    目录 Spark学习笔记0--简单了解和技术架构 什么是Spark 技术架构和软件栈 Spark Core Spark SQL Spark Streaming MLlib GraphX 集群管理器 受 ...

随机推荐

  1. [ jenkins ] 基础安装及权限管理

    1. 安装 jenkins 在安装 jenkins 之前需要 java 的支持 (1)安装 jdk1.8 [root@192.168.118.17 ~]#tar xf jdk-8u77-linux-x ...

  2. 把github代码自动部署到服务器

    一.参考文献 https://developer.github.com/webhooks/ https://docs.gitlab.com/ee/user/project/integrations/w ...

  3. HTML布局水平导航条2制作

    前两个博文导航条都不是铺满水平的浏览器的,很多导航条样式都是随着浏览器的移动,是100%.此外前两个博文导航条都是块状点击的,也就是给a标签加宽高,设置成块状显示,点击的时候不一定要点文字,只要点击该 ...

  4. Ubuntu18使用netplan设置多网口绑定

    Ubuntu18使用netplan设置网络参考:https://www.cnblogs.com/minseo/p/11325384.html 修改配置文件 /etc/netplan/50-cloud- ...

  5. Tomcat教程(转)

    转载链接: https://www.cnblogs.com/jingmoxukong/p/8258837.html?utm_source=gold_browser_extension 简介 Tomca ...

  6. Elasticsearch聚合操作报错解决办法

    1. 当根据一个类型为text的字段idc进行聚合操作时,查询语句如下: { "aggs": { "top_10_states": { "terms& ...

  7. [SVN] - 使用 TortoiseSVN 进行文件比对非常慢 之 解决

    背景 Windows 10 + TortoiseSVN-v1.9.7使用默认的 TortoiseMerge 进行文件比对,打开速度非常非常慢. 解决 禁用 TortoiseMerge / Settin ...

  8. C++程序的多文件组成

    C++程序的多文件组成 [例3.32] 一个源程序按照结构划分为3个文件 // 文件1 student.h (类的声明部分) #include<iostream.h> #include&l ...

  9. 基于TCP的编程

    前提:本文基于Linux系统下的学习 服务器端 1 创建通讯端口,返回socket设备的文件描述符 sfdsocket(2)#include <sys/types.h> /* See NO ...

  10. dotnet Core学习之旅(序)

    .NET Core 新玩具,新工具,新生产力 我将在博客园我从0.1开始探索.NET Core 的过程. 为什么是从0.1开始而不是从0开始 我在微软刚宣布开源的时候便接触到了.NET Core 1. ...