Spark RDD算子大全(Java、Scala双版本)
一.Spark RDD概念
概述
- RDD是将数据项拆分为多个分区的集合，存储在集群的工作节点上的内存中，并执行指定操作
- RDD是用于数据转换的接口
- RDD指向了存储在HDFS、Cassandra、HBase等、或缓存（内存、内存+磁盘、仅磁盘等），或在故障或缓存收回时重新计算其他RDD分区中的数据
特性
- 分布式数据集
- RDD是只读的、分区记录的集合，每个分区分布在集群的不同节点上
- RDD并不存储真正的数据，只是对数据和操作的描述
- 弹性
- RDD默认存放在内存中，当内存不足，Spark自动将RDD写入磁盘
- 容错性
- 根据数据血统，可以自动从节点失败中恢复分区
二.RDD的几种创建方式（Scala语言）
- 第一种：使用集合List创建
//关键字：parallelize、List
//Spark默认会根据集群的情况来设置分区的数量，也可以通过parallelize的第二参数来指定
val rdd:RDD[String] = sc.parallelize(List("hello world","hello java","hello scala"))
- 第二种：通过加载文件创建RDD
//相对路径：当前工程根目录下的data目录下的hello.txt文件
val rdd:RDD[String]=sc.textFile("data/hello.txt")
//绝对路径：D盘目录下的hello.txt文件
val rdd:RDD[String]=sc.textFile("D:/hello.txt")
//读取HDFS上的文件
//Spark默认为HDFS文件的每一个数据块创建一个分区，也可以通过textFile()第二个参数指定，但只能比数据块数量多
val rdd:RDD[String]=sc.textFile("hdfs://IP地址:端口号/目录/文件")
三.算子(lazy、non-lazy)
- Transformation（lazy）：转换算子
- Actions（non-lazy）：动作算子
使用Transformation算子实际只会记录RDD的转换过程但不会真正执行，只有遇到Action算子才会真正的执行前面的动作算子
举个栗子：textFile读取本地文件来创建RDD，哪怕实际上该文件并不存在，也能成功创建RDD。当RDD遇到第一个行动算子( actions)操作时，需要对RDD进行计算，此时才会报错，明白了没？也就说明了转化操作的本质:仅仅是记录旧RDD如何转化成新RDD ,但不会立即进行计算，以免浪费资源。
常用的转换算子
Scala版
//对每个元素执行指定操作
println("_____________map算子___________________")
val mapRdd:RDD[String]=sc.parallelize(List("hello","world"))
//通过map将每个元素形成元组
mapRdd.map((_,1)).collect.foreach(println)
/*输出结果：
(hello,1)
(world,1)
*/
//过滤器
println("____________filter算子_________________")
val filterRdd:RDD[Int]=sc.parallelize(List(1,2,3,4,5))
filterRdd.filter(_%2==0).collect.foreach(println)
/*输出结果：
2
4
*/
//只对value进行操作
println("____________mapValue算子_________________")
val mapvalueRdd:RDD[(Int,String)] = sc.parallelize(List("dog","tiger","cat")).map(x=>(x.length,x))
mapvalueRdd.mapValues(x=>"*"+x+"*").collect.foreach(println)
/*输出结果：
(3,*dog*)
(5,*tiger*)
(3,*cat*)
*/
//去重
println("______________distinct算子________________")
val disRdd:RDD[Int]=sc.parallelize(List(1,2,2,2,3,3,4))
disRdd.distinct.collect.foreach(println)
/*输出结果：
1
2
3
4*/
//根据判断key值是否相等来决定是不是执行括号内的代码
println("______________reduceByKey算子________________")
val rbkRdd:RDD[(Int,String)] = sc.parallelize(List("dog","tiger","cat","lion","eagle")).map(x=>(x.length,x))
rbkRdd.reduceByKey((a,b)=>a+b).collect.foreach(println)
/*输出结果：
(3,dogcat)
(4,lion)
(5,tigereagle)
*/
println("______________groupBykey算子________________")
val gbkRdd:RDD[(Int,String)] = sc.parallelize(List("dog","tiger","cat","lion","eagle")).map(x=>(x.length,x))
//返回的value是迭代器
val gbkRdd2:RDD[(Int,Iterable[String])]=gbkRdd.groupByKey()
gbkRdd3.collect.foreach(println)
/*输出结果：
(3,CompactBuffer(dog,cat))
(4,CompactBuffer(lion))
(5,CompactBuffer(tiger,eagle))
*/
//聚合
println("______________union算子________________")
val unRdd1:RDD[Int]=sc.parallelize(List(1,2))
val unRdd2:RDD[Int]=sc.parallelize(List(3,4))
unRdd1.union(unRdd2).collect.foreach(println)
/*输出结果：
1
2
3
4
*/
//返回左集合不存在于右集合的所有元素
println("___________________subtract算子_______________________")
val rddSub:RDD[Int] = sc.parallelize(List(1,2,3,4))
val rddSub2:RDD[Int] = sc.parallelize(List(1,2,3))
rddSub.subtract(rddSub2).collect.foreach(x=>print(x+","))
/*输出结果：
4
*/
//将两个集合中key值相同的元素连接
println("___________________join算子_______________________")
val rddJoin:RDD[(String,Int)] = sc.parallelize(List(new Tuple2[String,Int]("a",1),new Tuple2[String,Int]("b",1)))
val rddJoin2:RDD[(String,Int)] = sc.parallelize(List(new Tuple2[String,Int]("a",2),new Tuple2[String,Int]("a",2),new Tuple2[String,Int]("b",2),new Tuple2[String,Int]("c",2)))
rddJoin.join(rddJoin2).collect.foreach(println)
/*输出结果：
(a,(1,2))
(a,(1,2))
(b,(1,2))*/
//全连接，存在相同key的元素和join一样，不存在相同的key的则返回None
println("___________________fullOuterJoin算子_______________________")
val rddFoj:RDD[(String,Int)] = sc.parallelize(List(new Tuple2[String,Int]("a",1),new Tuple2[String,Int]("b",1)))
val rddFoj2:RDD[(String,Int)] = sc.parallelize(List(new Tuple2[String,Int]("a",2),new Tuple2[String,Int]("b",2),new Tuple2[String,Int]("c",2)))
rddFoj.fullOuterJoin(rddFoj2).collect.foreach(println)
/*输出结果：
(a,(Some(1),Some(2)))
(b,(Some(1),Some(2)))
(c,(None,Some(2)))*/
//左关联:右集合中有无关联的丢弃，左边有无关联的保留
println("___________________LeftOuterJoin算子_______________________")
val rddLoj:RDD[(String,Int)] = sc.parallelize(List(new Tuple2[String,Int]("a",1),new Tuple2[String,Int]("b",1),new Tuple2[String,Int]("c",1)))
val rddLoj2:RDD[(String,Int)] = sc.parallelize(List(new Tuple2[String,Int]("a",2),new Tuple2[String,Int]("b",2),new Tuple2[String,Int]("d",2)))
rddLoj.leftOuterJoin(rddLoj2).collect.foreach(println)
/*输出结果：
(a,(1,Some(2)))
(b,(1,Some(2)))
(c,(1,None))*/
//右关联:左集合中有无关联的丢弃，右边有无关联的保留
println("___________________RightOuterJoin算子_______________________")
val rddRoj:RDD[(String,Int)] = sc.parallelize(List(new Tuple2[String,Int]("a",1),new Tuple2[String,Int]("b",1),new Tuple2[String,Int]("c",1)))
val rddRoj2:RDD[(String,Int)] = sc.parallelize(List(new Tuple2[String,Int]("a",2),new Tuple2[String,Int]("b",2),new Tuple2[String,Int]("d",2)))
rddRoj.rightOuterJoin(rddRoj2).collect.foreach(println)
/*输出结果：
(d,(None,2))
(a,(Some(1),2))
(b,(Some(1),2))*/
}
}
JAVA版本
//过滤器，根据条件筛选元素
System.out.println("_________________filter算子________________________");
//创建ArrayList集合
ArrayList<Integer> arrFilter = new ArrayList<>();
arrFilter.add(1);
arrFilter.add(2);
arrFilter.add(3);
//创建RDD，将集合作为RDD数据源
JavaRDD<Integer> rddFilter = sc.parallelize(arrFilter);
//方法：def filter(f : org.apache.spark.api.java.function.Function[T, java.lang.Boolean]) : org.apache.spark.api.java.JavaRDD[T]
//解释：参数为Function对象，重写call方法，指定call方法的输入类型为Integer，返回值为Boolean类型，因为实现的是判断元素是否满足指定条件，算子会根据判断结果来决定是否返回元素
//实现：判断元素对2取余是否等于0
JavaRDD<Integer> rddFilter2 = rddFilter.filter(new Function<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) throws Exception {
return integer % 2 == 0;
}
});
//使用collect算子，将元素转成list集合
List<Integer> collectFilter = rddFilter2.collect();
//遍历list集合
for (Integer integer : collectFilter) {
System.out.println(integer);
}
/*
* 输出结果：
* 2
* */
//对所有元素进行相同操作，返回RDD中的元素个数，与原RDD元素个数一一对应
System.out.println("_________________map算子________________________");
//创建ArrayList集合
ArrayList<Integer> arrMap = new ArrayList<>();
arrMap.add(1);
arrMap.add(2);
arrMap.add(3);
//创建RDD，将集合作为RDD数据源
JavaRDD<Integer> rddMap = sc.parallelize(arrMap);
//方法：def map[R](f : org.apache.spark.api.java.function.Function[T, R]) : org.apache.spark.api.java.JavaRDD[R]
//解释：在map算子中创建Function对象，重写call方法(创建Function需要指定重写call方法的输入、输出类型)
//实现：将所有元素对2取余
JavaRDD<Integer> rddMap2 = rddMap.map(new Function<Integer, Integer>() {
@Override
public Integer call(Integer integer) throws Exception {
return integer % 2;
}
});
List<Integer> collect = rddMap2.collect();
for (Integer integer : collect) {
System.out.println(integer);
}
/*输出结果：
* 1
* 0
* 1*/
//一个元素，生成多个元素
System.out.println("_________________flatMap算子________________________");
ArrayList<String> arrFlatMap = new ArrayList<>();
arrFlatMap.add("hello world");
arrFlatMap.add("hello scala");
arrFlatMap.add("hello spark");
JavaRDD<String> rddFlatMap = sc.parallelize(arrFlatMap);
//方法：def flatMap[U](f : org.apache.spark.api.java.function.FlatMapFunction[T, U]) : org.apache.spark.api.java.JavaRDD[U]
//解释：flatMap的参数是FlatMapFunction对象，指定重写方法的输入类型为String，返回的类型是元组Tuple2常用的动作算子
scala版
//返回第一个元素
println("_____________first_________________")
val rddFirst:RDD[Int] = sc.parallelize(List(1,2,3,4))
println(rddFirst.first())
/*输出结果：
1
*/
//返回第前n个元素
println("_____________take_________________")
val rddTake:RDD[Int] = sc.parallelize(List(1,2,3,4))
val rddTakeArray = rddTake.take(2)
for (elem <- rddTakeArray) {
println(elem)
}
/*输出结果：
1
2
*/
//返回RDD中所有元素
println("_____________collect_________________")
val rddCollect:RDD[Int] = sc.parallelize(List(1,2,3,4))
val ints = rddCollect.collect()
for (elem <- ints) {
println(elem)
}
/*输出结果：
1
2
3
4*/
//返回RDD中元素个数
println("_____________count_________________")
val rddCount:RDD[Int] = sc.parallelize(List(1,2,3,4))
println(rddCount.count())
/*输出结果：
4
*/
//返回RDD中各元素出现的次数
println("_____________countByValue_________________")
val rddCBV:RDD[Int] = sc.parallelize(List(1,1,2,3,3,4))
val rddCBVmap = rddCBV.countByValue()
for (elem <- rddCBVmap) {
println(elem._1+"出现了："+elem._2+"次")
}
/*输出结果：
1出现了：2次
2出现了：1次
3出现了：2次
4出现了：1次*/
//并行整合RDD中所有数据
println("_____________reduce_________________")
val rddReduce:RDD[Int] = sc.parallelize(List(1,2,3,4))
println(rddReduce.reduce(_ + _))
/*输出结果：
10
*/
//和 reduce() 一 样， 但是提供了初始值num,每个元素计算时，先要合这个初始值进行折叠, 注意，这里会按照每个分区进行fold，然后分区之间还会再次进行fold
println("_____________fold_________________")
val rddFold:RDD[Int] = sc.parallelize(List(1,2,3,4),2)
println(rddFold.fold(1)((x,y)=>{println(x,y);x+y}))
/*输出结果：
(当分区为1 的时候) 12
(当分区为2 的时候) 13
...
*/
//按照升序排列rdd，根据传入的参数取前n个元素
println("_____________top_________________")
val rddTop:RDD[Int] = sc.parallelize(List(1,2,3,4))
val arrayTop = rddTop.top(2)
for (elem <- arrayTop) {
println(elem)
}
/*输出结果：
4
3
*/
//于top相反，将rdd按降序排列，取前n个元素
println("_____________takeOrdered_________________")
val rddTo:RDD[Int] = sc.parallelize(List(1,2,3,4))
val arrayTo = rddTo.takeOrdered(2)
for (elem <- arrayTo) {
println(elem)
}
/* 输出结果：
1
2
*/
//对RDD中的每个元素执行指定函数
println("_____________foreach_____________________")
val rdd:RDD[Int] = sc.parallelize(List(1,2,3,4))
rdd.foreach(println)
/*输出结果(存在分区，每次输出顺序会不同)：
1
2
3
4*/