RDD以及其特点
1、RDD是Spark提供的核心抽象,全称为Resillient Distributed Dataset,即弹性分布式数据集。
2、RDD在抽象上来说是一种元素集合,包含了数据。它是被分区的,分为多个分区,每个分区分布在集群中的不同节点上,从而让RDD中的数据可以被并行操作。(分布式数据集)
3、RDD通常通过Hadoop上的文件,即HDFS文件或者Hive表,来进行创建;有时也可以通过应用程序中的集合来创建。
4、RDD最重要的特性就是,提供了容错性,可以自动从节点失败中恢复过来。即如果某个节点上的RDD partition,因为节点故障,导致数据丢了,那么RDD会自动通过自己的数据来源重新计算该partition。这一切对使用者是透明的。
5、RDD的数据默认情况下存放在内存中的,但是在内存资源不足时,Spark会自动将RDD数据写入磁盘。(弹性)
要使用Spark,开发者需要编写一个Driver程序,它被提交到集群以调度运行Worker,如下图所示。
Driver中定义了一个或多个RDD,并调用RDD上的action;
Worker则执行RDD分区计算任务。
master:集群主节点;
worker:集群从节点;
Dirver: 驱动器节点;
Executor:执行器节点;
WorldCount实列
统计文件如下:
java编写
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 org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.api.java.function.VoidFunction;
import scala.Tuple2;
import java.util.Arrays;
public class WordCountLocal_3 {
public static void main(String[] args) {
//编写Spark应用程序本地执行
//第一步:创建SparkConf对象,设置Spark的应用信息
//使用setMaster设置Spark应用程序要链接的集群master的url,
//local代表本地运行
SparkConf conf = new SparkConf()
.setAppName("WordCountLocal_3")
.setMaster("local");
// 第二步:创建JavaSparkContext对象
// 在Spark中,SparkContext是Spark所有功能的一个入口,你无论是用java、scala,甚至是python编写
// 都必须要有一个SparkContext,它的主要作用,包括初始化Spark应用程序所需的一些核心组件,包括
// 调度器(DAGSchedule、TaskScheduler),还会去到Spark Master节点上进行注册,等等
// 一句话,SparkContext,是Spark应用中,可以说是最最重要的一个对象
// 但是呢,在Spark中,编写不同类型的Spark应用程序,使用的SparkContext是不同的,如果使用scala,
// 使用的就是原生的SparkContext对象
// 但是如果使用Java,那么就是JavaSparkContext对象
// 如果是开发Spark SQL程序,那么就是SQLContext、HiveContext
// 如果是开发Spark Streaming程序,那么就是它独有的SparkContext
// 以此类推
JavaSparkContext sc = new JavaSparkContext(conf);
// 第三步:要针对输入源(hdfs文件、本地文件,等等),创建一个初始的RDD
// 输入源中的数据会打散,分配到RDD的每个partition中,从而形成一个初始的分布式的数据集
// 我们这里呢,因为是本地测试,所以呢,就是针对本地文件
// SparkContext中,用于根据文件类型的输入源创建RDD的方法,叫做textFile()方法
// 在Java中,创建的普通RDD,都叫做JavaRDD
// 在这里呢,RDD中,有元素这种概念,如果是hdfs或者本地文件呢,创建的RDD,每一个元素就相当于
// 是文件里的一行
/*有几个事项是需要注意的:
1、如果是针对本地文件的话,如果是在windows上本地测试,windows上有一份文件即可;如果是在spark集群上针对linux本地文件,那么需要将文件拷贝到所有worker节点上。
2、Spark的textFile()方法支持针对目录、压缩文件以及通配符进行RDD创建。
3、Spark默认会为hdfs文件的每一个block创建一个partition,但是也可以通过textFile()的第二个参数手动设置分区数量,只能比block数量多,不能比block数量少*/
/*Spark的textFile()除了可以针对上述几种普通的文件创建RDD之外,还有一些特列的方法来创建RDD:
1、SparkContext.wholeTextFiles()方法,可以针对一个目录中的大量小文件,返回<filename, fileContent>组成的pair,作为一个PairRDD,而不是普通的RDD。普通的textFile()返回的RDD中,每个元素就是文件中的一行文本。
2、SparkContext.sequenceFile[K, V]()方法,可以针对SequenceFile创建RDD,K和V泛型类型就是SequenceFile的key和value的类型。K和V要求必须是Hadoop的序列化类型,比如IntWritable、Text等。
3、SparkContext.hadoopRDD()方法,对于Hadoop的自定义输入类型,可以创建RDD。该方法接收JobConf、InputFormatClass、Key和Value的Class。
4、SparkContext.objectFile()方法,可以针对之前调用RDD.saveAsObjectFile()创建的对象序列化的文件,反序列化文件中的数据,并创建一个RDD。*/
JavaRDD<String> lines = sc.textFile("D:\\eclipse\\wc\\scalaworid\\spark.txt");
// 第四步:对初始RDD进行transformation操作,也就是一些计算操作
// 通常操作会通过创建function,并配合RDD的map、flatMap等算子来执行
// function,通常,如果比较简单,则创建指定Function的匿名内部类
// 但是如果function比较复杂,则会单独创建一个类,作为实现这个function接口的类
// 先将每一行拆分成单个的单词
// FlatMapFunction,有两个泛型参数,分别代表了输入和输出类型
// 我们这里呢,输入肯定是String,因为是一行一行的文本,输出,其实也是String,因为是每一行的文本切分后的单词
// 这里先简要介绍flatMap算子的作用,其实就是,将RDD的一个元素,给拆分成一个或多个元素
JavaRDD<String> worlds = lines.flatMap(new FlatMapFunction<String, String>() {
@Override
public Iterable<String> call(String line) throws Exception {
return Arrays.asList(line.split(" "));
}
});
// 接着,需要将每一个单词,映射为(单词, 1)的这种格式
// 因为只有这样,后面才能根据单词作为key,来进行每个单词的出现次数的累加
// mapToPair,其实就是将每个元素,映射为一个(v1,v2)这样的Tuple2类型的元素
// 如果大家还记得scala里面讲的tuple,那么没错,这里的tuple2就是scala类型,包含了两个值
// mapToPair这个算子,要求的是与PairFunction配合使用,第一个泛型参数代表了输入类型
// 第二个和第三个泛型参数,代表的输出的Tuple2的第一个值和第二个值的类型
// JavaPairRDD的两个泛型参数,分别代表了tuple元素的第一个值和第二个值的类型
JavaPairRDD<String, Integer> pairs = worlds.mapToPair(new PairFunction<String, String, Integer>() {
@Override
public Tuple2<String, Integer> call(String word) throws Exception {
return new Tuple2<String, Integer>(word, 1);
}
});
// 接着,需要以单词作为key,统计每个单词出现的次数
// 这里要使用reduceByKey这个算子,对每个key对应的value,都进行reduce操作
// 比如JavaPairRDD中有几个元素,分别为(hello, 1) (hello, 1) (hello, 1) (world, 1)
// reduce操作,相当于是把第一个值和第二个值进行计算,然后再将结果与第三个值进行计算
// 比如这里的hello,那么就相当于是,首先是1 + 1 = 2,然后再将2 + 1 = 3
// 最后返回的JavaPairRDD中的元素,也是tuple,但是第一个值就是每个key,第二个值就是key的value
// reduce之后的结果,相当于就是每个单词出现的次数
JavaPairRDD<String, Integer> wordcounts = pairs.reduceByKey(new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer v1, Integer v2) throws Exception {
return v1 + v2;
}
});
// 到这里为止,我们通过几个Spark算子操作,已经统计出了单词的次数
// 但是,之前我们使用的flatMap、mapToPair、reduceByKey这种操作,都叫做transformation操作
// 一个Spark应用中,光是有transformation操作,是不行的,是不会执行的,必须要有一种叫做action
// 接着,最后,可以使用一种叫做action操作的,比如说,foreach,来触发程序的执行
wordcounts.foreach(new VoidFunction<Tuple2<String, Integer>>() {
@Override
public void call(Tuple2<String, Integer> t) throws Exception {
System.out.println(t._1 + ":" + t._2);
}
});
}
}
部分结果如下:
scala编写
import org.apache.spark.{SparkConf, SparkContext}
object Wordcount {
def main(args: Array[String]): Unit = {
val conf = new SparkConf()
.setAppName("Wordcount")
.setMaster("local")
val sc = new SparkContext(conf)
val lines: RDD[String] = sc.textFile("E:\\sparktext\\spark.txt")
val worlds: RDD[String] = lines.flatMap(_.split(" "))
//worlds.map((world:String) => (world,1))
val worldAndOne: RDD[(String, Int)] = worlds.map((_,1))
//worldAndOne.reduceByKey((v1:Int,v2:Int) => v1 + v2)
//worldAndOne.reduceByKey( v1 + v2)
val worldCount: RDD[(String, Int)] = worldAndOne.reduceByKey( _ + _)
val unit: Unit = worldCount.foreach(wc => println(wc._1 + ":" + wc._2))
//worldCount.foreach(println)
}
}
scala一行代码
import org.apache.spark.{SparkConf, SparkContext}
object Wordcount {
def main(args: Array[String]): Unit = {
val conf = new SparkConf()
.setAppName("Wordcount")
.setMaster("local")
val sc = new SparkContext(conf)
sc.textFile("E:\\sparktext\\spark.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).foreach(println)
}
}
RDD创建
进行Spark核心编程时,首先要做的第一件事,就是创建一个初始的RDD。该RDD中,通常就代表和包含了Spark应用程序的输入源数据。然后在创建了初始的RDD之后,才可以通过Spark Core提供的transformation算子,对该RDD进行转换,来获取其他的RDD。
Spark Core提供了三种创建RDD的方式,包括:使用程序中的集合创建RDD;使用本地文件创建RDD;使用HDFS文件创建RDD。
个人理解
1、使用程序中的集合创建RDD,主要用于进行测试,可以在实际部署到集群运行之前,自己使用集合构造测试数据,来测试后面的spark应用的流程。
2、使用本地文件创建RDD,主要用于临时性地处理一些存储了大量数据的文件。
3、使用HDFS文件创建RDD,应该是最常用的生产环境处理方式,主要可以针对HDFS上存储的大数据,进行离线批处理操作。
并行化集合创建RDD
如果要通过并行化集合来创建RDD,需要针对程序中的集合,调用SparkContext。parallelize()方法。Spark会将集合中的数据拷贝到集群上去,形成一个分布式的数据集合,也就是一个RDD。相当于是,集合中的部分数据会到一个节点上,而另一部分数据会到其他节点上。然后就可以用并行的方式来操作这个分布式数据集合,即RDD。
// 案例:1到10累加求和
val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val rdd = sc.parallelize(arr)
val sum = rdd.reduce(_ + _)
调用parallelize()时,有一个重要的参数可以指定,就是要将集合切分成多少个partition。Spark会为每一个partition运行一个task来进行处理。Spark官方的建议是,为集群中的每个CPU创建2~4个partition。Spark默认会根据集群的情况来设置partition的数量。但是也可以在调用parallelize()方法时,传入第二个参数,来设置RDD的partition数量。比如parallelize(arr, 10)
使用本地文件和HDFS创建RDD
Spark是支持使用任何Hadoop支持的存储系统上的文件创建RDD的,比如说HDFS、Cassandra、HBase以及本地文件。通过调用SparkContext的textFile()方法,可以针对本地文件或HDFS文件创建RDD。
有几个事项是需要注意的:
1、如果是针对本地文件的话,如果是在windows上本地测试,windows上有一份文件即可;如果是在spark集群上针对linux本地文件,那么需要将文件拷贝到所有worker节点上。
2、Spark的textFile()方法支持针对目录、压缩文件以及通配符进行RDD创建。
3、Spark默认会为hdfs文件的每一个block创建一个partition,但是也可以通过textFile()的第二个参数手动设置分区数量,只能比block数量多,不能比block数量少。
import org.apache.spark.SparkConf;
import org.apache.spark.SparkContext;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.Function2;
/**
* * 案例:统计文本文件字数
*/
public class LocalFile_5 {
public static void main(String[] args) {
SparkConf conf = new SparkConf()
.setMaster("local")
.setAppName("LocalFile_5");
JavaSparkContext sc = new JavaSparkContext(conf);
// 使用SparkContext以及其子类的textFile()方法,针对本地文件创建RDD
JavaRDD<String> Length = sc.textFile("D:\\eclipse\\wc\\scalaworid\\spark.txt");
final JavaRDD<Integer> lines = Length.map(new Function<String, Integer>() {
@Override
public Integer call(String line) throws Exception {
return line.length();
}
});
Integer count = lines.reduce(new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer v1, Integer v2) throws Exception {
return v1 + v2;
}
});
System.out.println("文件出现单词的总数: " + count);
sc.close();
}
}
Spark的textFile()除了可以针对上述几种普通的文件创建RDD之外,还有一些特列的方法来创建RDD:
1、SparkContext.wholeTextFiles()方法,可以针对一个目录中的大量小文件,返回<filename, fileContent>组成的pair,作为一个PairRDD,而不是普通的RDD。普通的textFile()返回的RDD中,每个元素就是文件中的一行文本。
2、SparkContext.sequenceFileK, V方法,可以针对SequenceFile创建RDD,K和V泛型类型就是SequenceFile的key和value的类型。K和V要求必须是Hadoop的序列化类型,比如IntWritable、Text等。
3、SparkContext.hadoopRDD()方法,对于Hadoop的自定义输入类型,可以创建RDD。该方法接收JobConf、InputFormatClass、Key和Value的Class。
4、SparkContext.objectFile()方法,可以针对之前调用RDD.saveAsObjectFile()创建的对象序列化的文件,反序列化文件中的数据,并创建一个RDD。
transformation和action介绍
Spark支持两种RDD操作:transformation和action。transformation操作会针对已有的RDD创建一个新的RDD;而action则主要是对RDD进行最后的操作,比如遍历、reduce、保存到文件等,并可以返回结果给Driver程序。
例如,map就是一种transformation操作,它用于将已有RDD的每个元素传入一个自定义的函数,并获取一个新的元素,然后将所有的新元素组成一个新的RDD。而reduce就是一种action操作,它用于对RDD中的所有元素进行聚合操作,并获取一个最终的结果,然后返回给Driver程序。
transformation的特点就是lazy特性。lazy特性指的是,如果一个spark应用中只定义了,transformation操作,那么即使你执行该应用,这些操作也不会执行。也就是说,transformation是不会触发spark程序的执行的,它们只是记录了对RDD所做的操作,但是不会自发的执行。只有当transformation之后,接着执行了一个action操作,那么所有的transformation才会执行。Spark通过这种lazy特性,来进行底层的spark应用执行的优化,避免产生过多中间结果。
action操作执行,会触发一个spark job的运行,从而触发这个action之前所有的transformation的执行。这是action的特性。
常用transformation介绍
常用action介绍
常用transformation操作
map算子
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 org.apache.spark.api.java.function.VoidFunction;
import java.util.Arrays;
import java.util.List;
public class Transfromationa {
public static void main(String[] args) {
mymap();
}
/**
* map算子:对每一个元素*2
*/
private static void mymap(){
SparkConf conf = new SparkConf()
.setAppName("mymap")
.setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
//构建集合
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
//并行化集合,初始RDD
JavaRDD<Integer> numberRDD = sc.parallelize(list);
JavaRDD<Integer> map = numberRDD.map(new Function<Integer, Integer>() {
@Override
public Integer call(Integer integer) throws Exception {
return integer * 2;
}
});
// 打印新的RDD中的内容
map.foreach(new VoidFunction<Integer>() {
@Override
public void call(Integer integer) throws Exception {
System.out.println(integer);
}
});
}
}
filter算子
public class Transfromationa {
public static void main(String[] args) {
//mymap();
myFileter();
}
/**
* filter算子函数:过滤集合总的偶数
*/
private static void myFileter(){
SparkConf conf = new SparkConf()
.setMaster("local")
.setAppName("myFileter");
//创建SparkContext
JavaSparkContext sc = new JavaSparkContext(conf);
//模拟集合
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 12);
//并行化集合,初始化RDD
JavaRDD<Integer> numberRDD = sc.parallelize(numbers);
JavaRDD<Integer> filter = numberRDD.filter(new Function<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) throws Exception {
return integer % 2 == 0;
}
});
filter.foreach(new VoidFunction<Integer>() {
@Override
public void call(Integer integer) throws Exception {
System.out.println(integer);
}
});
sc.close();
}
}
flapMap算子
public class Transfromationa {
public static void main(String[] args) {
//mymap();
//myFileter();
myFlatMap();
}
/**
* flapMap案例:将文本拆分成多个单词
*/
private static void myFlatMap(){
SparkConf conf = new SparkConf()
.setAppName("myFlatMap")
.setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
//模拟集合
List<String> list = Arrays.asList("hello tom", "hello word", "hello kangkang");
JavaRDD<String> linesRDD = sc.parallelize(list);
// 对RDD执行flatMap算子,将每一行文本,拆分成多个单词
// flatMap算子,在java中,接受的参数是flatMapFunction
// 我们需要自己定义FlatMapFunction的第二个泛型类型,即,代表了返回的新元素的类型
// call()方法,返回类型,不是Object。而是Iterable<Object>,这里的Object也与第二个泛型类型相同
// flatMap其实就是,接受原始RDD中的每个元素,并进行各种逻辑计算和处理。返回多个元素
// 多个元素,即封装在Iterable中,可以使用ArrayList等集合
JavaRDD<String> stringJavaRDD = linesRDD.flatMap(new FlatMapFunction<String, String>() {
@Override
public Iterable<String> call(String s) throws Exception {
return Arrays.asList(s.split(" "));
}
});
stringJavaRDD.foreach(new VoidFunction<String>() {
@Override
public void call(String s) throws Exception {
System.out.println(s);
}
});
sc.close();
}
groupByKey算子
public class Transfromationa {
public static void main(String[] args) {
//mymap();
//myFileter();
//myFlatMap();
myGroupByKey();
}
/**
* groupByKey案例:按班级对成绩进行分类
*/
private static void myGroupByKey(){
SparkConf conf = new SparkConf()
.setMaster("local")
.setAppName("myGroupByKey");
JavaSparkContext sc = new JavaSparkContext(conf);
List<Tuple2<String,Integer>> objects = Arrays.asList(
new Tuple2<String, Integer>("class1",72),
new Tuple2<String, Integer>("class2",67),
new Tuple2<String, Integer>("class1",89),
new Tuple2<String, Integer>("class2",45)
);
JavaPairRDD<String, Integer> groupByscoure = sc.parallelizePairs(objects);
final JavaPairRDD<String, Iterable<Integer>> scores = groupByscoure.groupByKey();
scores.foreach(new VoidFunction<Tuple2<String, Iterable<Integer>>>() {
@Override
public void call(Tuple2<String, Iterable<Integer>> tuple2) throws Exception {
System.out.println("班级:" + tuple2._1);
Iterator<Integer> iterator = tuple2._2.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("------------");
}
});
sc.close();
}
reduceByKey算子
public class Transfromationa {
public static void main(String[] args) {
//mymap();
//myFileter();
//myFlatMap();
//myGroupByKey();
myReduceByKey();
}
/**
* reduceByKey:统计每个班级的总分
*/
private static void myReduceByKey(){
SparkConf conf = new SparkConf()
.setAppName("myReduceByKey")
.setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
List<Tuple2<String, Integer>> scoresClass = Arrays.asList(
new Tuple2<String, Integer>("class2",45),
new Tuple2<String, Integer>("class4",67),
new Tuple2<String, Integer>("class2",76),
new Tuple2<String, Integer>("class4",84)
);
JavaPairRDD<String, Integer> scoreRDD = sc.parallelizePairs(scoresClass);
// 针对scores DRR 执行reduceByKey
// reduceByKey,接受的参数是Function2类型,他有三个参数,实际上代表三个值
// 第一个泛型类型和第二个泛型类型,代表原始RDD中的元素value的类型
// 因此对每个key进行redce,都会一次将第一个,第二个value传入,将值在与第三个value传入
// 因此此处,也会自动定义两个泛型类型,代表call()方法的两个传入参数的类型
// 第三个泛型类型,代表了每次reduce操作返回值的类型,默认也是与原始RDD的value类型相同的
//reduceByKey算子返回的RDD,还是JavaPairRDD<key,value>
JavaPairRDD<String, Integer> scoreReduce = scoreRDD.reduceByKey(new Function2<Integer, Integer, Integer>() {
@Override
// 对每个key,都会将其value,依次传入call方法
// 从而聚合出每一个key对应的一个value
// 然后,将每一个key对应的一个value,组合称一个Tuple2,做为新的RDD的元素
public Integer call(Integer v1, Integer v2) throws Exception {
return v1 + v2;
}
});
scoreReduce.foreach(new VoidFunction<Tuple2<String, Integer>>() {
@Override
public void call(Tuple2<String, Integer> tuple2) throws Exception {
System.out.println(tuple2._1 + " : " + tuple2._2);
}
});
sc.close();
}
join与cogroup算子
public class Transfromationa {
public static void main(String[] args) {
//mymap();
//myFileter();
//myFlatMap();
//myGroupByKey();
//myReduceByKey();
myJoinAndCogroup();
}
/**
* join与cogroup:打印学生的成绩
*
*/
private static void myJoinAndCogroup(){
SparkConf conf = new SparkConf()
.setMaster("local")
.setAppName("myJoinAndCogroup");
JavaSparkContext sc = new JavaSparkContext(conf);
List<Tuple2<Integer,String>> stuList = Arrays.asList(
new Tuple2<Integer, String>(1,"zhaungsan"),
new Tuple2<Integer, String>(2,"lisi"),
new Tuple2<Integer, String>(3,"wangwu")
);
List<Tuple2<Integer,Integer>> scoreList = Arrays.asList(
new Tuple2<Integer, Integer>(1,100),
new Tuple2<Integer, Integer>(2,53),
new Tuple2<Integer, Integer>(3,76)
);
List<Tuple2<Integer, Integer>> scoreTwoList = Arrays.asList(
new Tuple2<Integer, Integer>(1, 100),
new Tuple2<Integer, Integer>(2, 90),
new Tuple2<Integer, Integer>(3, 60),
new Tuple2<Integer, Integer>(1, 70),
new Tuple2<Integer, Integer>(2, 80),
new Tuple2<Integer, Integer>(3, 50)
);
// 并行化两个RDD
JavaPairRDD<Integer, String> studets = sc.parallelizePairs(stuList);
JavaPairRDD<Integer, Integer> scoreOne = sc.parallelizePairs(scoreList);
JavaPairRDD<Integer, Integer> scoreTow = sc.parallelizePairs(scoreTwoList);
// 使用join关联两个RDD
// join后,还是会根据key进行join,并返回JavaPairRDD
// 但是JavaPairRDD的第一个泛型类型,之前两个JavaPairRDD的key的类型,因为是通过key进行join的
// 第二个泛型类型,是Tuple2<v1,v2>的类型,Tuple2的两个泛型分别是原始RDD的value类型
// join,就返回的RDD的每一个元素,就是通过key join上的一个pair
// 例如:(1,1) (1,2) (1,3)的一个RDD
//还有一个(1,4) (2,1) (2,2)的一个RDD
//join以后,实际上会得到(1,(1,4)) (1,(2,4)) (1,(3,4))
JavaPairRDD<Integer, Tuple2<String, Integer>> studentJoinScoreOne = studets.join(scoreOne);
studentJoinScoreOne.foreach(new VoidFunction<Tuple2<Integer, Tuple2<String, Integer>>>() {
@Override
public void call(Tuple2<Integer, Tuple2<String, Integer>> tuple2) throws Exception {
System.out.println(tuple2._1 + ":" + tuple2._2._1 + " : " + tuple2._2._2);
}
});
System.out.println("==============");
// cogroup与join不同
// 相当于,一个key join上的所有value,都放到一个Iterable里
JavaPairRDD<Integer, Tuple2<Iterable<String>, Iterable<Integer>>> studentsCogroupScoreOne = studets.cogroup(scoreTow);
studentsCogroupScoreOne.foreach(new VoidFunction<Tuple2<Integer, Tuple2<Iterable<String>, Iterable<Integer>>>>() {
@Override
public void call(Tuple2<Integer, Tuple2<Iterable<String>, Iterable<Integer>>> tuple2) throws Exception {
System.out.println(tuple2._1 + ":" + tuple2._2._1 + " : " + tuple2._2._2);
}
});
sc.close();
}
常用action操作
reduce算子
public class Actiona {
public static void main(String[] args) {
myReduce();
}
private static void myReduce(){
SparkConf conf = new SparkConf()
.setMaster("local")
.setAppName("myReduce");
JavaSparkContext sc = new JavaSparkContext(conf);
List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 7, 9, 9);
JavaRDD<Integer> numRDD = sc.parallelize(numList);
Integer sum = numRDD.reduce(new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer v1, Integer v2) throws Exception {
return v1 + v2;
}
});
System.out.println(sum);
sc.close();
}
}
collect算子
public class Actiona {
public static void main(String[] args) {
//myReduce();
mycollect();
}
private static void mycollect(){
SparkConf conf = new SparkConf()
.setMaster("local")
.setAppName("mycollect");
JavaSparkContext sc = new JavaSparkContext(conf);
List<Integer> numlist = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
JavaRDD<Integer> numRDD = sc.parallelize(numlist);
JavaRDD<Integer> map = numRDD.map(new Function<Integer, Integer>() {
@Override
public Integer call(Integer integer) throws Exception {
return integer * 3;
}
});
List<Integer> collect = map.collect();
for (Integer a:collect) {
System.out.println(a);
}
sc.close();
}
}
count算子
public class Actiona {
public static void main(String[] args) {
//myReduce();
//mycollect();
mycount();
}
/**
* 获取RDD元素总个数
*/
private static void mycount(){
SparkConf conf = new SparkConf()
.setMaster("local")
.setAppName("mycount");
JavaSparkContext sc = new JavaSparkContext(conf);
List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
JavaRDD<Integer> numRDD = sc.parallelize(numList);
long count = numRDD.count();
System.out.println(count);
}
take算子
public class Actiona {
public static void main(String[] args) {
//myReduce();
//mycollect();
//mycount();
mytake();
}
private static void mytake(){
SparkConf conf = new SparkConf()
.setMaster("local")
.setAppName("mytake");
JavaSparkContext sc = new JavaSparkContext(conf);
// 取集合中的前n的元素
List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
JavaRDD<Integer> numRDD = sc.parallelize(numList);
//take操作是从远程集群上获取RDD中的数据,但是只获取前n个
List<Integer> take = numRDD.take(5);
for (Integer a :take) {
System.out.println(a);
}
sc.close();
}
saveAsTextFile算子
public class Actiona {
public static void main(String[] args) {
//myReduce();
//mycollect();
//mycount();
//mytake();
mysaveAsTextFile();
}
private static void mysaveAsTextFile(){
SparkConf conf = new SparkConf()
.setMaster("local")
.setAppName("mysaveAsTextFile");
JavaSparkContext sc = new JavaSparkContext(conf);
List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 67, 788, 34);
JavaRDD<Integer> listRDD = sc.parallelize(numList);
JavaRDD<Integer> numbers = listRDD.map(new Function<Integer, Integer>() {
@Override
public Integer call(Integer integer) throws Exception {
return integer *2;
}
});
numbers.saveAsTextFile("D:\\eclipse\\wc\\scalaworid\\num.txt");
sc.close();
}
countByKey算子
public class Actiona {
public static void main(String[] args) {
//myReduce();
//mycollect();
//mycount();
//mytake();
//mysaveAsTextFile();
mycountByKey();
}
private static void mycountByKey(){
SparkConf conf = new SparkConf()
.setMaster("local")
.setAppName("mycountByKey");
JavaSparkContext sc = new JavaSparkContext(conf);
List<Tuple2<String,String>> asList = Arrays.asList(
new Tuple2<String, String>("class1","leo"),
new Tuple2<String, String>("class2","tom"),
new Tuple2<String, String>("class1","wahaha"),
new Tuple2<String, String>("class1","jack"),
new Tuple2<String, String>("class2","tyler")
);
// 并行化集合,创建JavaPairRDD
JavaPairRDD<String, String> pairRDD = sc.parallelizePairs(asList);
// 对rdd应用countByKey操作,统计每个班级学生人数,也就是统计每个key对应的元素个数
// 这句是countByKey的作用
Map<String, Object> countByKey = pairRDD.countByKey();
for (Map.Entry<String,Object> a:countByKey.entrySet()) {
System.out.println(a.getKey() + " :" + a.getValue());
}
sc.close();
}