spark shell操作
RDD有两种类型的操作 ，分别是Transformation（返回一个新的RDD）和Action（返回values）。
1.Transformation：根据已有RDD创建新的RDD数据集build
（1）map(func)：对调用map的RDD数据集中的每个element都使用func，然后返回一个新的RDD，这个返回的数据集是分布式的数据集。
（2）filter(func) ：对调用filter的RDD数据集中的每个元素都使用func，然后返回一个包含使func为true的元素构成的RDD。
（3）flatMap(func)：和map很像，但是flatMap生成的是多个结果。
（4）mapPartitions(func)：和map很像，但是map是每个element，而mapPartitions是每个partition。
（5）mapPartitionsWithSplit(func)：和mapPartitions很像，但是func作用的是其中一个split上，所以func中应该有index。
（6）sample(withReplacement,faction,seed)：抽样。
（7）union(otherDataset)：返回一个新的dataset，包含源dataset和给定dataset的元素的集合。
（8）distinct([numTasks])：返回一个新的dataset，这个dataset含有的是源dataset中的distinct的element。
（9）groupByKey(numTasks)：返回(K,Seq[V])，也就是Hadoop中reduce函数接受的key-valuelist。
（10）reduceByKey(func,[numTasks])：就是用一个给定的reduce func再作用在groupByKey产生的(K,Seq[V])，比如求和，求平均数。
（11）sortByKey([ascending],[numTasks])：按照key来进行排序，是升序还是降序，ascending是boolean类型。
2.Action：在RDD数据集运行计算后，返回一个值或者将结果写入外部存储
（1）reduce(func)：就是聚集，但是传入的函数是两个参数输入返回一个值，这个函数必须是满足交换律和结合律的。
（2）collect()：一般在filter或者足够小的结果的时候，再用collect封装返回一个数组。
（3）count()：返回的是dataset中的element的个数。
（4）first()：返回的是dataset中的第一个元素。
（5）take(n)：返回前n个elements。
（6）takeSample(withReplacement，num，seed)：抽样返回一个dataset中的num个元素，随机种子seed。
（7）saveAsTextFile（path）：把dataset写到一个textfile中，或者HDFS，或者HDFS支持的文件系统中，Spark把每条记录都转换为一行记录，然后写到file中。
（8）saveAsSequenceFile(path)：只能用在key-value对上，然后生成SequenceFile写到本地或者Hadoop文件系统。
（9）countByKey()：返回的是key对应的个数的一个map，作用于一个RDD。
（10）foreach(func)：对dataset中的每个元素都使用func。
用户id（buyer_id），商品id（goods_id），收藏日期（dt）
用户id 商品id 收藏日期
10181 1000481 2010-04-04 16:54:31
20001 1001597 2010-04-07 15:07:52
20001 1001560 2010-04-07 15:08:27
20042 1001368 2010-04-08 08:20:30
20067 1002061 2010-04-08 16:45:33
20056 1003289 2010-04-12 10:50:55
20056 1003290 2010-04-12 11:57:35
20056 1003292 2010-04-12 12:05:29
20054 1002420 2010-04-14 15:24:12
20055 1001679 2010-04-14 19:46:04
20054 1010675 2010-04-14 15:23:53
20054 1002429 2010-04-14 17:52:45
20076 1002427 2010-04-14 19:35:39
20054 1003326 2010-04-20 12:54:44
20056 1002420 2010-04-15 11:24:49
20064 1002422 2010-04-15 11:35:54
20056 1003066 2010-04-15 11:43:01
20056 1003055 2010-04-15 11:43:06
20056 1010183 2010-04-15 11:45:24
20056 1002422 2010-04-15 11:45:49
20056 1003100 2010-04-15 11:45:54
20056 1003094 2010-04-15 11:45:57
20056 1003064 2010-04-15 11:46:04
20056 1010178 2010-04-15 16:15:20
20076 1003101 2010-04-15 16:37:27
20076 1003103 2010-04-15 16:37:05
20076 1003100 2010-04-15 16:37:18
20076 1003066 2010-04-15 16:37:31
20054 1003103 2010-04-15 16:40:14
20054 1003100 2010-04-15 16:40:16
现要求统计用户收藏数据中，每个用户收藏商品数量。
1.在Linux上，创建/data/spark3/wordcount目录，用于存储实验所需的数据。
mkdir -p /data/spark3/wordcount
切换目录到/data/spark3/wordcount下，并从http://192.168.1.100:60000/allfiles/spark3/wordcount/buyer_favorite下载实验数据。
cd /data/spark3/wordcount
wget http://192.168.1.100:60000/allfiles/spark3/wordcount/buyer_favorite
2.使用jps查看Hadoop以及Spark的相关进程是否已经启动，若未启动则执行启动命令。
jps
/apps/hadoop/sbin/start-all.sh
/apps/spark/sbin/start-all.sh
将Linux本地/data/spark3/wordcount/buyer_favorite文件，上传到HDFS上的/myspark3/wordcount目录下。若HDFS上/myspark3目录不存在则需提前创建。
hadoop fs -mkdir -p /myspark3/wordcount
hadoop fs -put /data/spark3/wordcount/buyer_favorite /myspark3/wordcount
3.启动spark-shell
spark-shell
4.编写Scala语句，统计用户收藏数据中，每个用户收藏商品数量。
先在spark-shell中，加载数据。
val rdd = sc.textFile("hdfs://localhost:9000/myspark3/wordcount/buyer_favorite");
执行统计并输出。
rdd.map(line=> (line.split('\t')(0),1)).reduceByKey(_+_).collect
去重：使用spark-shell，对上述实验中，用户收藏数据文件进行统计。根据商品ID进行去重，统计用户收藏数据中都有哪些商品被收藏。
1.在Linux上，创建/data/spark3/distinct，用于存储实验数据。
mkdir -p /data/spark3/distinct
切换到/data/spark3/distinct目录下，并从http://192.168.1.100:60000/allfiles/spark3/distinct/buyer_favorite下载实验数据。
cd /data/spark3/distinct
wget http://192.168.1.100:60000/allfiles/spark3/distinct/buyer_favorite
2.使用jps查看Hadoop，Spark的进程。保证Hadoop、Spark框架相关进程为已启动状态。
3.将/data/spark3/distinct/buyer_favorite文件，上传到HDFS上的/myspark3/distinct目录下。若HDFS目录不存在则创建。
hadoop fs -mkdir -p /myspark3/distinct
hadoop fs -put /data/spark3/distinct/buyer_favorite /myspark3/distinct
4.在Spark窗口，编写Scala语句，统计用户收藏数据中，都有哪些商品被收藏。
先加载数据，创建RDD。
val rdd = sc.textFile("hdfs://localhost:9000/myspark3/distinct/buyer_favorite");
对RDD进行统计并将结果打印输出。
rdd.map(line => line.split('\t')(1)).distinct.collect
排序：电商网站都会对商品的访问情况进行统计，现有一个goods_visit文件，存储了电商网站中的各种商品以及此各个商品的点击次数。
商品id（goods_id） 点击次数（click_num）
商品ID 点击次数
1010037 100
1010102 100
1010152 97
1010178 96
1010280 104
1010320 103
1010510 104
1010603 96
1010637 97
现根据商品的点击次数进行排序，并输出所有商品。
输出结果样式：
点击次数 商品ID
96 1010603
96 1010178
97 1010637
97 1010152
100 1010102
100 1010037
103 1010320
104 1010510
104 1010280
1.在Linux上，创建/data/spark3/sort，用于存储实验数据。
mkdir -p /data/spark3/sort
切换到/data/spark3/sort目录下，并从http://192.168.1.100:60000/allfiles/spark3/sort/goods_visit下载实验数据。
cd /data/spark3/sort
wget http://192.168.1.100:60000/allfiles/spark3/sort/goods_visit
2.将/data/spark3/sort/goods_visit文件，上传到HDFS上的/spark3/sort/目录下。若HDFS目录不存在则需提前创建。
hadoop fs -mkdir -p /myspark3/sort
hadoop fs -put /data/spark3/sort/goods_visit /myspark3/sort
3.在Spark窗口，加载数据，将数据转变为RDD。
val rdd1 = sc.textFile("hdfs://localhost:9000/myspark3/sort/goods_visit");
对RDD进行统计并将结果打印输出。
rdd1.map(line => ( line.split('\t')(1).toInt, line.split('\t')(0) ) ).sortByKey(true).collect
4.输出结果样式为：
Join：现有某电商在2011年12月15日的部分交易数据。数据有订单表orders和订单明细表order_items，表结构及数据分别为：
orders表：（订单id order_id, 订单号 order_number, 买家ID buyer_id, 下单日期 create_dt）
订单ID 订单号 用户ID 下单日期
52304 111215052630 176474 2011-12-15 04:58:21
52303 111215052629 178350 2011-12-15 04:45:31
52302 111215052628 172296 2011-12-15 03:12:23
52301 111215052627 178348 2011-12-15 02:37:32
52300 111215052626 174893 2011-12-15 02:18:56
52299 111215052625 169471 2011-12-15 01:33:46
52298 111215052624 178345 2011-12-15 01:04:41
52297 111215052623 176369 2011-12-15 01:02:20
52296 111215052622 178343 2011-12-15 00:38:02
52295 111215052621 178342 2011-12-15 00:18:43
52294 111215052620 178341 2011-12-15 00:14:37
52293 111215052619 178338 2011-12-15 00:13:07
order_items表：（明细ID item_id, 订单ID order_id, 商品ID goods_id ）
明细ID 订单ID 商品ID
252578 52293 1016840
252579 52293 1014040
252580 52294 1014200
252581 52294 1001012
252582 52294 1022245
252583 52294 1014724
252584 52294 1010731
252586 52295 1023399
252587 52295 1016840
252592 52296 1021134
252593 52296 1021133
252585 52295 1021840
252588 52295 1014040
252589 52296 1014040
252590 52296 1019043
orders表和order_items表，通过订单id进行关联，是一对多的关系。
下面开启spark-shell，查询在当天该电商网站，都有哪些用户购买了什么商品。
1.在Linux上，创建/data/spark3/join，用于存储实验数据。
```bash
mkdir -p /data/spark3/join
切换目录到/data/spark3/join目录下，并从http://192.168.1.100:60000/allfiles/spark3/join/order_items及http://192.168.1.100:60000/allfiles/spark3/join/orders下载实验数据。
cd /data/spark3/join
wget http://192.168.1.100:60000/allfiles/spark3/join/order_items
wget http://192.168.1.100:60000/allfiles/spark3/join/orders
2.在HDFS上创建/myspark3/join目录，并将Linux上/data/spark3/join目录下的数据，上传到HDFS。
hadoop fs -mkdir -p /myspark3/join
hadoop fs -put /data/spark3/join/orders /myspark3/join
hadoop fs -put /data/spark3/join/order_items /myspark3/join
3.在Spark窗口创建两个RDD，分别加载orders文件以及order_items文件中的数据。
val rdd1 = sc.textFile("hdfs://localhost:9000/myspark3/join/orders");
val rdd2 = sc.textFile("hdfs://localhost:9000/myspark3/join/order_items");
4.我们的目的是查询每个用户购买了什么商品。所以对rdd1和rdd2进行map映射，得出关键的两个列的数据。
val rdd11 = rdd1.map(line=> (line.split('\t')(0), line.split('\t')(2)) )
val rdd22 = rdd2.map(line=> (line.split('\t')(1), line.split('\t')(2)) )
5.将rdd11以及rdd22中的数据，根据Key值，进行Join关联，得到最终结果。
```scala
val rddresult = rdd11 join rdd22
6.最后将结果输出，查看输出效果。
rddresult.collect
最终的执行结果为：
7.将输出数据进行格式化：
(52294,(178341,1014200)),
(52294,(178341,1001012)),
(52294,(178341,1022245)),
(52294,(178341,1014724)),
(52294,(178341,1010731)),
(52296,(178343,1021134)),
(52296,(178343,1021133)),
(52296,(178343,1014040)),
(52296,(178343,1019043)),
(52295,(178342,1023399)),
(52295,(178342,1016840)),
(52295,(178342,1021840)),
(52295,(178342,1014040)),
(52293,(178338,1016840)),
(52293,(178338,1014040))
可以看到上面数据关联后一共有3列，分别为订单ID，用户ID，商品ID。
求平均值：电商网站都会对商品的访问情况进行统计。现有一个goods_visit文件，存储了全部商品及各商品的点击次数。还有一个文件goods，记录了商品的基本信息。两张表的数据结构如下：
goods表：商品ID（goods_id），商品状态（goods_status），商品分类id（cat_id），评分（goods_score）
goods_visit表：商品ID（goods_id），商品点击次数（click_num）
商品表（goods）及商品访问情况表（goods_visit）可以根据商品id进行关联。现在统计每个分类下，商品的平均点击次数是多少？
1.在Linux上，创建目录/data/spark3/avg，用于存储实验数据。
mkdir -p /data/spark3/avg
切换到/data/spark3/avg目录下，并从http://192.168.1.100:60000/allfiles/spark3/avg/goods以及http://192.168.1.100:60000/allfiles/spark3/avg/goods_visit两个网址下载实验数据。
cd /data/spark3/avg
wget http://192.168.1.100:60000/allfiles/spark3/avg/goods
wget http://192.168.1.100:60000/allfiles/spark3/avg/goods_visit
2.在HDFS上创建目录/myspark3/avg，并将Linux/data/spark3/avg目录下的数据，上传到HDFS的/myspark3/avg。
hadoop fs -mkdir -p /myspark3/avg
hadoop fs -put /data/spark3/avg/goods /myspark3/avg
hadoop fs -put /data/spark3/avg/goods_visit /myspark3/avg
3.在Spark窗口创建两个RDD，分别加载goods文件以及goods_visit文件中的数据。
val rdd1 = sc.textFile("hdfs://localhost:9000/myspark3/avg/goods")
val rdd2 = sc.textFile("hdfs://localhost:9000/myspark3/avg/goods_visit")
4.我们的目的是统计每个分类下，商品的平均点击次数，我们可以分三步来做。
首先，对rdd1和rdd2进行map映射，得出关键的两个列的数据。
val rdd11 = rdd1.map(line=> (line.split('\t')(0), line.split('\t')(2)) )
val rdd22 = rdd2.map(line=> (line.split('\t')(0), line.split('\t')(1)) )
用collect()方法启动程序。
rdd11.collect
查看rdd11的结果如下：
rdd11.collect
res2: Array[(String, String)] = Array((1000002,52137), (1000003,52137), (1000004,52137), (1000006,52137),
(1000007,52137), (1000008,52137), (1000010,52137), (1000011,52137), (1000015,52137), (1000018,52137),
(1000020,52137), (1000021,52137), (1000025,52137), (1000028,52137), (1000030,52137), (1000033,52137),
(1000035,52137), (1000037,52137), (1000041,52137), (1000044,52137), (1000048,52137), (1000050,52137),
(1000053,52137), (1000057,52137), (1000059,52137), (1000063,52137), (1000065,52137), (1000067,52137),
(1000071,52137), (1000073,52137), (1000076,52137), (1000078,52137), (1000080,52137), (1000082,52137),
(1000084,52137), (1000086,52137), (1000087,52137), (1000088,52137), (1000090,52137), (1000091,52137),
(1000094,52137), (1000098,52137), (1000101,52137), (1000103,52137), (1000106,52...
scala>>
用collect()方法启动程序。
rdd22.collect
查看rdd22的结果如下：
rdd22.collect
res3: Array[(String, String)] = Array((1010000,4), (1010001,0), (1010002,0), (1010003,0), (1010004,0),
(1010005,0), (1010006,74), (1010007,0), (1010008,0), (1010009,1081), (1010010,0), (1010011,0), (1010012,0),
(1010013,44), (1010014,1), (1010018,0), (1010019,542), (1010020,1395), (1010021,18), (1010022,13), (1010023,27),
(1010024,22), (1010025,295), (1010026,13), (1010027,1), (1010028,410), (1010029,2), (1010030,8), (1010031,6),
(1010032,729), (1010033,72), (1010034,3), (1010035,328), (1010036,153), (1010037,100), (1010038,4), (1010039,3),
(1010040,69), (1010041,1), (1010042,1), (1010043,21), (1010044,268), (1010045,11), (1010046,1), (1010047,1),
(1010048,59), (1010049,15), (1010050,19), (1010051,424), (1010052,462), (1010053,9), (1010054,41), (1010055,64),
(1010056,10), (1010057,3), (...
scala>
然后，将rdd11以及rdd22中的数据根据商品ID，也就是key值进行关联，得到一张大表。表结构变为：（商品id，（商品分类，商品点击次数））
view plain copy
val rddjoin = rdd11 join rdd22
用collect()方法启动程序。
view plain copy
rddjoin.collect
查看rddjoin的结果如下：
view plain copy
rddjoin.collect
res4: Array[(String, (String, String))] = Array((1013900,(52137,0)), (1010068,(52007,1316)), (1018970,(52006,788)),
(1020975,(52091,68)), (1019960,(52111,0)), (1019667,(52045,16)), (1010800,(52137,6)), (1019229,(52137,20)), (1022649,
(52119,90)), (1020382,(52137,0)), (1022667,(52021,150)), (1017258,(52086,0)), (1021963,(52072,83)), (1015809,(52137,285)),
(1024340,(52084,0)), (1011043,(52132,0)), (1011762,(52137,2)), (1010976,(52132,34)), (1010512,(52090,8)), (1023965,(52095,0)),
(1017285,(52069,41)), (1020212,(52026,46)), (1010743,(52137,0)), (1020524,(52064,52)), (1022577,(52090,13)), (1021974,(52069,22)),
(1010543,(52137,0)), (1010598,(52136,53)), (1017212,(52108,45)), (1010035,(52006,328)), (1010947,(52089,8)), (1020964,(52071,86)),
(1024001,(52063,0)), (1020191,(52046,0)), (1015739,(...
scala>
最后，在大表的基础上，进行统计。得到每个分类，商品的平均点击次数。
view plain copy
rddjoin.map(x=>{(x._2._1, (x._2._2.toLong, 1))}).reduceByKey((x,y)=>{(x._1+y._1, x._2+y._2)}).map(x=>{(x._1, x._2._1*1.0/x._2._2)}).collect
将结果输出，查看输出效果。
view plain copy
scala> rddjoin.map(x=>{(x._2._1, (x._2._2.toLong, 1))}).reduceByKey((x,y)=>{(x._1+y._1, x._2+y._2)}).map(x=>
{(x._1, x._2._1*1.0/x._2._2)}).collect
res40: Array[(String, Double)] = Array((52009,463.3642857142857), (52135,36.69230769230769), (52128,9.0), (52072,42.8),
(52078,16.5), (52137,34.735241502683365), (52047,20.96551724137931), (52050,0.0), (52056,24.57894736842105),
(52087,17.008928571428573), (52085,31.17142857142857), (52007,547.3076923076923), (52052,19.6), (52081,50.833333333333336),
(52016,106.75), (52058,34.23170731707317), (52124,0.0), (52092,28.453703703703702), (52065,8.644444444444444), (52106,22.5),
(52120,96.7843137254902), (52027,114.7), (52089,17.81159420289855), (52098,57.793103448275865), (52038,74.2), (52061,52.609375),
(52104,49.0), (52014,45.4), (52012,53.26), (52100,22.0), (52043,23.0), (52030,532.48), (52023,150.0), (52083,57.857142857142854),
(52041,40.0), (52049,18.058823529411764), (52074,33.17647058...
scala>
spark shell操作的更多相关文章
- spark教程(二)-shell操作
spark 支持 shell 操作 shell 主要用于调试,所以简单介绍用法即可 支持多种语言的 shell 包括 scala shell.python shell.R shell.SQL shel ...
- Spark源码分析之Spark Shell（上）
终于开始看Spark源码了,先从最常用的spark-shell脚本开始吧.不要觉得一个启动脚本有什么东东,其实里面还是有很多知识点的.另外,从启动脚本入手,是寻找代码入口最简单的方法,很多开源框架,其 ...
- Spark源码分析之Spark Shell（下）
继上次的Spark-shell脚本源码分析,还剩下后面半段.由于上次涉及了不少shell的基本内容,因此就把trap和stty放在这篇来讲述. 上篇回顾:Spark源码分析之Spark Shell(上 ...
- 【原创 Hadoop&Spark 动手实践 5】Spark 基础入门，集群搭建以及Spark Shell
Spark 基础入门,集群搭建以及Spark Shell 主要借助Spark基础的PPT,再加上实际的动手操作来加强概念的理解和实践. Spark 安装部署 理论已经了解的差不多了,接下来是实际动手实 ...
- Spark Shell简单使用
基础 Spark的shell作为一个强大的交互式数据分析工具,提供了一个简单的方式学习API.它可以使用Scala(在Java虚拟机上运行现有的Java库的一个很好方式)或Python.在Spark目 ...
- 02、体验Spark shell下RDD编程
02.体验Spark shell下RDD编程 1.Spark RDD介绍 RDD是Resilient Distributed Dataset,中文翻译是弹性分布式数据集.该类是Spark是核心类成员之 ...
- HDFS的基本shell操作，hadoop fs操作命令
(1)分布式文件系统 随着数据量越来越多,在一个操作系统管辖的范围存不下了,那么就分配到更多的操作系统管理的磁盘中,但是不方便管理和维护,因此迫切需要一种系统来管理多台机器上的文件,这就是分布式文件管 ...
- Spark shell的原理
Spark shell是一个特别适合快速开发Spark原型程序的工具,可以帮助我们熟悉Scala语言.即使你对Scala不熟悉,仍然可以使用这个工具.Spark shell使得用户可以和Spark集群 ...
- Spark RDD/Core 编程 API入门系列之动手实战和调试Spark文件操作、动手实战操作搜狗日志文件、搜狗日志文件深入实战（二）
1.动手实战和调试Spark文件操作 这里,我以指定executor-memory参数的方式,启动spark-shell. 启动hadoop集群 spark@SparkSingleNode:/usr/ ...
随机推荐
- 免费试用 | 多模 NoSQL 服务GeminiDB for Cassandra 全球首发
PS:多模NoSQL服务GeminiDB重磅公测,免费体验,参与公测还有华为AI音响好礼相送~ 7月5日,华为云多模 NoSQL 服务GeminiDB for Cassandra正式对外定向邀测.华为 ...
- angularJS使用ocLazyLoad实现js延迟加载
最近开发一个系统遇到了一个问题,用angular路由一个html片段,该片段需要使用一个js插件来实现一个富文本编辑器.关键问题在于必须要在片段加载后通过js与dom元素进行绑定.一开始想当然以为直接 ...
- 一道时间复杂度为O(N)空间复杂度为O(1)的排序问题
题目:对1, 2, ... , n的一个无序数组,排序,要求时间复杂度为O(N),空间复杂度为O(1). 思路:该题利用数组元素和数组下标相差1的关系,Java代码如下: import java.ut ...
- （全国多校重现赛一）F-Senior Pan
Senior Pan fails in his discrete math exam again. So he asks Master ZKC to give him graph theory pro ...
- 导出excel时，跳转新空白页，不要跳转怎么改
导出excel的时候,偶尔会出现跳转到一个新页面再导出excel js中用window.open()做跳转 不想让它跳转到新页面,需要加一个隐藏的iframe <iframe name=&quo ...
- 【React】377- 实现 React 中的状态自动保存
点击上方"前端自习课"关注,学习起来~ 作者:陈俊宇 https://github.com/CJY0208 什么是状态保存? 假设有下述场景: 移动端中,用户访问了一个列表页,上拉 ...
- 【JS】369- 20个常用的JavaScript字符串方法
点击上方"前端自习课"关注,学习起来~ 作者:前端小智 https://segmentfault.com/a/1190000020204425 本文主要介绍一些最常用的JS字符串函 ...
- Python中最简单快捷的输出方式
格式化输出最简单的方式之哑巴填充公式 name=ludundun age=25 print(f'hello {name},your age is {age}') 输出内容: hello ludundu ...
- 前后端分离crud（跨域问题）讲解
1 前后端分离 1.1 后端 ssm+maven 多模块 swagger 文档描述(代码拷贝过来,就可以生成了,https://www.cnblogs.com/wings-xh/p/11991511. ...
- leaflet视频监控播放(附源码下载)
前言 leaflet 入门开发系列环境知识点了解: leaflet api文档介绍,详细介绍 leaflet 每个类的函数以及属性等等 leaflet 在线例子 leaflet 插件,leaflet ...