将集合中每个元素乘以2
map：将集合中每个元素乘以2
使用map算子，将集合中的每个元素都乘以2
map算子，是对任何类型的RDD，都可以调用的，在Java中，map算子接收的参数是Function对象
创建的Function对象，一定会让你设置第二个泛型参数，这个泛型类型，就是返回的新元素的类型
同时call()方法的返回类型，也必须与第二个泛型类型同步
在call()方法内部，就可以对原始RDD中的每一个元素进行各种处理和计算，并返回一个新的元素
所有新的元素，就会组成一个新的RDD
java版本
// map：将集合中每个元素乘以2
public static void map() {
// 创建SparkConf
SparkConf sparkConf = new SparkConf().setAppName("LineCountJava").setMaster("local");
// 创建JavaSparkContext
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
// 创建集合
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// 并行化集合，创建初始化RDD
JavaRDD<Integer> numsRDD = javaSparkContext.parallelize(nums);
// 使用map算子，将集合中的每个元素都乘以2
// map算子，是对任何类型的RDD，都可以调用的，在Java中，map算子接收的参数是Function对象
// 创建的Function对象，一定会让你设置第二个泛型参数，这个泛型类型，就是返回的新元素的类型
// 同时call()方法的返回类型，也必须与第二个泛型类型同步
// 在call()方法内部，就可以对原始RDD中的每一个元素进行各种处理和计算，并返回一个新的元素
// 所有新的元素，就会组成一个新的RDD
JavaRDD<Integer> multipleNumberRDD = numsRDD.map(new Function<Integer, Integer>() {
@Override
public Integer call(Integer integer) throws Exception {
return integer * 2;
}
});
multipleNumberRDD.foreach(new VoidFunction<Integer>() {
@Override
public void call(Integer integer) throws Exception {
System.out.println("integer = " + integer);
}
});
// 关闭javaSparkContext
javaSparkContext.close();
}
scala版本
def map(): Unit = {
val conf = new SparkConf().setAppName("mapScala").setMaster("local")
val sparkContext = new SparkContext(conf)
val numsRDD = sparkContext.parallelize(1 to 10)
val multipleNumbersRDD = numsRDD.map(num => num * 2)
multipleNumbersRDD.foreach(num => println("num = " + num))
}
过滤出集合中的偶数
filter：过滤出集合中的偶数
filter算子，传入的也是Function，其他的使用注意点，实际上和map是一样的
但是唯一的不同，就是call()方法的返回类型是Boolean
每一个初始RDD中的元素，都会传入call()方法，此时你可以执行各种自定义的计算逻辑,来判断这个元素是否是你想要的
如果你想在新的RDD中保留这个元素，那么就返回true，否则，不想保留这个元素，返回false
java版本
/**
* filter算子案例，过滤集合中的偶数
*/
public static void filter(){
// 创建SparkConf
SparkConf sparkConf = new SparkConf().setAppName("filterJava").setMaster("local");
// 创建JavaSparkContext
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
// 创建集合
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// 并行化集合，创建初始化RDD
JavaRDD<Integer> numsRDD = javaSparkContext.parallelize(nums);
// 对初始RDD执行filter算子，过滤其中的偶数
// filter算子，传入的也是Function，其他的使用注意点，实际上和map是一样的
// 但是唯一的不同，就是call()方法的返回类型是Boolean
// 每一个初始RDD中的元素，都会传入call()方法，此时你可以执行各种自定义的计算逻辑
// 来判断这个元素是否是你想要的
// 如果你想在新的RDD中保留这个元素，那么就返回true，否则，不想保留这个元素，返回false
JavaRDD<Integer> evenNumberRDD = numsRDD.filter(new Function<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) throws Exception {
return integer % 2 == 0;
}
});
// 打印新的RDD
evenNumberRDD.foreach(new VoidFunction<Integer>() {
@Override
public void call(Integer integer) throws Exception {
System.out.println("integer = " + integer);
}
});
// 关闭javaSparkContext
javaSparkContext.close();
}
scala版本
def filter(): Unit = {
val conf = new SparkConf().setAppName("filterScala").setMaster("local")
val sparkContext = new SparkContext(conf)
val numsRDD = sparkContext.parallelize(1 to 10)
val evenNumberRDD = numsRDD.filter(num => num % 2 == 0)
evenNumberRDD.foreach(num => println("num = " + num))
}
将行拆分为单词
flatMap：将行拆分为单词
flatMap算子，在Java中，接收的参数是FlatMapFunction
我们需要自己定义FlatMapFunction的第一个泛型类型，即，代表了返回的新元素的类型
call()方法，返回的类型，不是U，而是Iterable<U>,这里的U也与第二个泛型类型相同
flatMap其实就是，接收原始RDD中的每个元素，并进行各种逻辑的计算和处理，返回可以返回多个元素
多个元素，即封装在Iterable集合中，可以使用ArrayList等集合
新的RDD中，即封装了所有的新元素，也就是说，新的RDD大小一定是大于等于原始RDD的大小
java版本
/**
* flatMap：将行拆分为单词
*/
private static void flatMap() {
// 创建SparkConf
SparkConf sparkConf = new SparkConf().setAppName("flatMapJava").setMaster("local");
// 创建JavaSparkContext
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
// 创建集合
List<String> lineList = Arrays.asList("hello spark", "hello hadoop", "hello yarn");
// 并行化集合，创建初始化RDD
JavaRDD<String> linesRDD = javaSparkContext.parallelize(lineList);
// 对RDD执行flatMap算子，将每一行文本，拆分为多个单词
// flatMap算子，在Java中，接收的参数是FlatMapFunction
// 我们需要自己定义FlatMapFunction的第一个泛型类型，即，代表了返回的新元素的类型
// call()方法，返回的类型，不是U，而是Iterable<U>,这里的U也与第二个泛型类型相同
// flatMap其实就是，接收原始RDD中的每个元素，并进行各种逻辑的计算和处理，返回可以返回多个元素
// 多个元素，即封装在Iterable集合中，可以使用ArrayList等集合
// 新的RDD中，即封装了所有的新元素，也就是说，新的RDD大小一定是大于等于原始RDD的大小
JavaRDD<String> words = linesRDD.flatMap(new FlatMapFunction<String, String>() {
@Override
public Iterable<String> call(String s) throws Exception {
return Arrays.asList(s.split(" "));
}
});
// 打印新的RDD
words.foreach(new VoidFunction<String>() {
@Override
public void call(String s) throws Exception {
System.out.println("s = " + s);
}
});
// 关闭javaSparkContext
javaSparkContext.close();
}
scala版本
def flatMap(): Unit = {
val conf = new SparkConf().setAppName("flatMapScala").setMaster("local")
val sparkContext = new SparkContext(conf)
val lines = sparkContext.parallelize(Array("hello spark", "hello hadoop", "hello yarn"))
val words = lines.flatMap(line => line.split(" "))
words.foreach(word => println("word = " + word))
}
将每个班级的成绩进行分组
groupByKey：将每个班级的成绩进行分组
执行groupByKey算子，返回的还是JavaPairRDD
但是，JavaPairRDD的第一个泛型类型不变，第二个泛型类型变成Iterable这种集合类型
也就是说，按照了key进行分组，那么每个key可能都会有多个value，此时多个value聚合成了Iterable
那么接下来，我们就可以通过groupedScoreRDD这种JavaPairRDD，很方便的处理某个分组内的数据
java版本
/**
* groupByKey：将每个班级的成绩进行分组
*/
public static void groupByKey() {
// 创建SparkConf
SparkConf sparkConf = new SparkConf().setAppName("groupByKeyJava").setMaster("local");
// 创建JavaSparkContext
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
// 创建集合
List<Tuple2<String, Integer>> scoreList = Arrays.asList(
new Tuple2<String, Integer>("class1", 80),
new Tuple2<String, Integer>("class2", 80),
new Tuple2<String, Integer>("class1", 95),
new Tuple2<String, Integer>("class2", 85)
);
// 并行化集合，创建初始化RDD
JavaPairRDD<String, Integer> scoreRDD = javaSparkContext.parallelizePairs(scoreList);
// 针对scoreRDD，执行groupByKey算子，对每个班级的成绩进行分组
// 执行groupByKey算子，返回的还是JavaPairRDD
// 但是，JavaPairRDD的第一个泛型类型不变，第二个泛型类型变成Iterable这种集合类型
// 也就是说，按照了key进行分组，那么每个key可能都会有多个value，此时多个value聚合成了Iterable
// 那么接下来，我们就可以通过groupedScoreRDD这种JavaPairRDD，很方便的处理某个分组内的数据
JavaPairRDD<String, Iterable<Integer>> groupedScoreRDD = scoreRDD.groupByKey();
// 打印groupedScoreRDD
groupedScoreRDD.foreach(new VoidFunction<Tuple2<String, Iterable<Integer>>>() {
@Override
public void call(Tuple2<String, Iterable<Integer>> stringIterableTuple2) throws Exception {
System.out.println("stringIterableTuple2._1 = " + stringIterableTuple2._1);
Iterable<Integer> integers = stringIterableTuple2._2;
for(Integer score : integers) {
System.out.println("score = " + score);
}
}
});
// 关闭javaSparkContext
javaSparkContext.close();
}
scala版本
def groupByKey(): Unit = {
val conf = new SparkConf().setAppName("groupByKeyScala").setMaster("local")
val sparkContext = new SparkContext(conf)
val scores = Array(("class1", 80), ("class2", 80), ("class1", 95), ("class2", 85))
val scoreRDD = sparkContext.parallelize(scores)
val groupedScoreRDD = scoreRDD.groupByKey()
groupedScoreRDD.foreach(score => {
println("className " + score._1)
score._2.foreach(score => println("score " + score))
})
}
统计每个班级的总分
reduceByKey：统计每个班级的总分
reduceByKey,接收的参数是Function2类型，它有三个泛型参数，实际上代表了三个值
第一个泛型类型和第二个泛型类型，代表了原始RDD中的元素的value的类型
因此对每个key进行reduce，都会依次将第一个、第二个value传入，将返回的值再与第三个value传入
因此此处，会自动定义两个类型参数类型，代表call()方法的两个传入参数的类型
第三个类型参数，代表了每次reduce操作返回的值的类型，默认也是与原始RDD的value类型相同的
reduceByKey算子返回的RDD，还是JavaPairRDD<Key,Value>
java版本
/**
* reduceByKey：统计每个班级的总分
*/
public static void reduceByKey() {
// 创建SparkConf
SparkConf sparkConf = new SparkConf().setAppName("reduceByKeyJava").setMaster("local");
// 创建JavaSparkContext
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
// 创建集合
List<Tuple2<String, Integer>> scoreList = Arrays.asList(
new Tuple2<String, Integer>("class1", 80),
new Tuple2<String, Integer>("class2", 80),
new Tuple2<String, Integer>("class1", 95),
new Tuple2<String, Integer>("class2", 85)
);
// 并行化集合，创建初始化RDD
JavaPairRDD<String, Integer> scoreRDD = javaSparkContext.parallelizePairs(scoreList);
// 针对scoreRDD，执行reduceByKey算子
// reduceByKey,接收的参数是Function2类型，它有三个泛型参数，实际上代表了三个值
// 第一个泛型类型和第二个泛型类型，代表了原始RDD中的元素的value的类型
// 因此对每个key进行reduce，都会依次将第一个、第二个value传入，将返回的值再与第三个value传入
// 因此此处，会自动定义两个类型参数类型，代表call()方法的两个传入参数的类型
// 第三个类型参数，代表了每次reduce操作返回的值的类型，默认也是与原始RDD的value类型相同的
// reduceByKey算子返回的RDD，还是JavaPairRDD<Key,Value>
JavaPairRDD<String, Integer> totalScoreRDD = scoreRDD.reduceByKey(new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer integer, Integer integer2) throws Exception {
return integer + integer2;
}
});
//遍历reducedScore
totalScoreRDD.foreach(new VoidFunction<Tuple2<String, Integer>>() {
@Override
public void call(Tuple2<String, Integer> stringIntegerTuple2) throws Exception {
System.out.println(stringIntegerTuple2._1 + "班级的总分为 " + stringIntegerTuple2._2);
}
});
// 关闭javaSparkContext
javaSparkContext.close();
}
scala版本
def reduceByKey(): Unit = {
val conf = new SparkConf().setAppName("reduceByKeyScala").setMaster("local")
val sparkContext = new SparkContext(conf)
val scores = Array(("class1", 80), ("class2", 80), ("class1", 95), ("class2", 85))
val scoreRDD = sparkContext.parallelize(scores)
val totalScoreRDD = scoreRDD.reduceByKey(_ + _)
totalScoreRDD.foreach(score => println(score._1 + "班级总分为：" + score._2))
}
将学生分数进行排序
sortByKey：将学生分数进行排序
sortByKey其实就是根据key进行排序，可以手动指定升序，或者降序
返回的，还是JavaPairRDD，其中元素内容，都是和原始RDD一模一样的，就是RDD中元素顺序不一样了
java版本
/**
* sortByKey：将学生分数进行排序
*/
private static void sortByKey() {
// 创建SparkConf
SparkConf sparkConf = new SparkConf().setAppName("sortByKeyJava").setMaster("local");
// 创建JavaSparkContext
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
// 创建集合
List<Tuple2<Integer, String>> scoreList = Arrays.asList(
new Tuple2<Integer, String>(80,"Zhao Jun"),
new Tuple2<Integer, String>(85,"Feng Xiangbin"),
new Tuple2<Integer, String>( 70,"Zhu"),
new Tuple2<Integer, String>(100,"Shou")
);
// 并行化集合，创建初始化RDD
JavaPairRDD<Integer, String> scoreRDD = javaSparkContext.parallelizePairs(scoreList);
// 对scoreRDD 执行sortByKey算子
// sortByKey其实就是根据key进行排序，可以手动指定升序，或者降序
// 返回的，还是JavaPairRDD，其中元素内容，都是和原始RDD一模一样的
// 就是顺序不一样了
//
JavaPairRDD<Integer, String> sortedScore = scoreRDD.sortByKey(false);
sortedScore.foreach(new VoidFunction<Tuple2<Integer, String>>() {
@Override
public void call(Tuple2<Integer, String> integerStringTuple2) throws Exception {
System.out.println(integerStringTuple2._2 + "的分数为" + integerStringTuple2._1);
}
});
// 关闭javaSparkContext
javaSparkContext.close();
}
scala版本
def sortByKey(): Unit = {
val conf = new SparkConf().setAppName("sortByKeyScala").setMaster("local")
val sparkContext = new SparkContext(conf)
val scores = Array((70, "Zhao Jun"), (80, "Feng Xiangbin"), (95, "Shou"), (85, "Zhu"))
val scoresRDD = sparkContext.parallelize(scores)
val sortedRDD = scoresRDD.sortByKey(false)
sortedRDD.foreach(score => println(score._2 + "的成绩为：" + score._1))
}
打印每个学生的成绩
join：打印每个学生的成绩
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))
java版本
/**
* join：打印每个学生的成绩
*/
public static void join() {
// 创建SparkConf
SparkConf sparkConf = new SparkConf().setAppName("joinJava").setMaster("local");
// 创建JavaSparkContext
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
// 创建集合
List<Tuple2<Integer, String>> student = Arrays.asList(
new Tuple2<Integer, String>(1,"Zhao Jun"),
new Tuple2<Integer, String>(2,"Feng Xiangbin"),
new Tuple2<Integer, String>(3,"Pang"),
new Tuple2<Integer, String>(4,"Shou")
);
List<Tuple2<Integer, Integer>> score = Arrays.asList(
new Tuple2<Integer, Integer>(1,90),
new Tuple2<Integer, Integer>(2,100),
new Tuple2<Integer, Integer>(3,80),
new Tuple2<Integer, Integer>(4,70)
);
// 并行化集合，创建初始化RDD
JavaPairRDD<Integer, String> studentRDD = javaSparkContext.parallelizePairs(student);
JavaPairRDD<Integer, Integer> scoreRDD = javaSparkContext.parallelizePairs(score);
// 使用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>> studentScore = studentRDD.join(scoreRDD);
// 遍历studentScore
studentScore.foreach(new VoidFunction<Tuple2<Integer, Tuple2<String, Integer>>>() {
@Override
public void call(Tuple2<Integer, Tuple2<String, Integer>> studentScore) throws Exception {
System.out.println("学号：" + studentScore._1 + " 姓名：" + studentScore._2._1 + " 分数：" + studentScore._2._2);
}
});
// 关闭javaSparkContext
javaSparkContext.close();
}
scala版本
def join(): Unit = {
val conf = new SparkConf().setAppName("joinScala").setMaster("local")
val sparkContext = new SparkContext(conf)
val student = Array((1, "Zhao Jun"), (2, "Feng Xiangbin"), (3, "Shou"), (4, "Zhu"))
val scores = Array((1, 90), (2, 80), (3, 100), (4, 70))
val studentRDD = sparkContext.parallelize(student)
val scoreRDD = sparkContext.parallelize(scores)
val studentScore = studentRDD.join(scoreRDD)
studentScore.foreach(sc => println("学号：" + sc._1 + "姓名：" + sc._2._1 + "分数：" + sc._2._2))
}
打印每个学生的成绩
cogroup：打印每个学生的成绩
相当于是，一个key join上的所有value，都给放到一个Iterable里面去了
cogroup，不太好讲解，希望通过动手编写我们的案例，仔细体会其中的奥妙
java版本
/**
* cogroup：打印每个学生的成绩
*/
public static void cogroup() {
// 创建SparkConf
SparkConf sparkConf = new SparkConf().setAppName("cogroupJava").setMaster("local");
// 创建JavaSparkContext
JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);
// 创建集合
List<Tuple2<Integer, String>> student = Arrays.asList(
new Tuple2<Integer, String>(1,"Zhao Jun"),
new Tuple2<Integer, String>(2,"Feng Xiangbin"),
new Tuple2<Integer, String>(3,"Pang"),
new Tuple2<Integer, String>(4,"Shou")
);
List<Tuple2<Integer, Integer>> score = Arrays.asList(
new Tuple2<Integer, Integer>(1,90),
new Tuple2<Integer, Integer>(2,100),
new Tuple2<Integer, Integer>(3,80),
new Tuple2<Integer, Integer>(4,70),
new Tuple2<Integer, Integer>(1,80),
new Tuple2<Integer, Integer>(2,90),
new Tuple2<Integer, Integer>(3,70),
new Tuple2<Integer, Integer>(4,60)
);
// 并行化集合，创建初始化RDD
JavaPairRDD<Integer, String> studentRDD = javaSparkContext.parallelizePairs(student);
JavaPairRDD<Integer, Integer> scoreRDD = javaSparkContext.parallelizePairs(score);
// 使用cogroup算子关联两个RDD
// 相当于是，一个key join上的所有value，都给放到一个Iterable里面去了
// cogroup，不太好讲解，希望通过动手编写我们的案例，仔细体会其中的奥妙
JavaPairRDD<Integer, Tuple2<Iterable<String>, Iterable<Integer>>> studentScore = studentRDD.cogroup(scoreRDD);
studentScore.foreach(new VoidFunction<Tuple2<Integer, Tuple2<Iterable<String>, Iterable<Integer>>>>() {
@Override
public void call(Tuple2<Integer, Tuple2<Iterable<String>, Iterable<Integer>>> integerTuple2Tuple2) throws Exception {
}
});
// 遍历studentScore
studentScore.foreach(new VoidFunction<Tuple2<Integer, Tuple2<Iterable<String>, Iterable<Integer>>>>() {
@Override
public void call(Tuple2<Integer, Tuple2<Iterable<String>, Iterable<Integer>>> t) throws Exception {
System.out.println("student id: " + t._1);
System.out.println("student name: " + t._2._1);
System.out.println("student score: " + t._2._2);
System.out.println("===============================");
}
});
// 关闭javaSparkContext
javaSparkContext.close();
}
scala版本
def cogroup(): Unit ={
val conf = new SparkConf().setAppName("cogroupScala").setMaster("local")
val sparkContext = new SparkContext(conf)
val student = Array((1, "Zhao Jun"), (2, "Feng Xiangbin"), (3, "Shou"), (4, "Zhu"))
val scores = Array((1, 90), (2, 80), (3, 100), (4, 70),(1, 80), (2, 70), (3, 90), (4, 60))
val studentRDD = sparkContext.parallelize(student)
val scoreRDD = sparkContext.parallelize(scores)
val studentScore = studentRDD.cogroup(scoreRDD)
studentScore.foreach(sc => {
println("学号：" + sc._1 )
println("姓名：" + sc._2._1.mkString(",") )
println("分数：" + sc._2._2.mkString(",") )
})
}
94
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
