本文详细介绍了Spark算子的使用，包括map、filter、flatMap、groupByKey、reduceByKey和sortByKey等，通过Java代码展示了这些操作在处理数据集时的具体应用和效果，帮助理解Spark数据处理的基本流程。
- map算子：将集合中的每个元素乘2
package cn.spark.sparktest; import java.util.Arrays; import java.util.List; 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; /** * transformation操作实战 * @author Administrator * */ public class transformationOpertion { public static void main(String[] args) { map(); } /** * map算子案例：将集合中每一个元素都乘以2 */ private static void map() { // 创建SparkConf SparkConf conf = new SparkConf() .setAppName("map") .setMaster("local"); // 创建JavaSparkContext JavaSparkContext sc = new JavaSparkContext(conf); // 构造集合 List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); // 并行化集合，创建初始RDD JavaRDD<Integer> numberRDD = sc.parallelize(numbers); // 使用map算子，将集合中的每个元素都乘以2 // map算子，是对任何类型的RDD，都可以调用的 // 在java中，map算子接收的参数是Function对象 // 创建的Function对象，一定会让你设置第二个泛型参数，这个泛型类型，就是返回的新元素的类型 // 同时call()方法的返回类型，也必须与第二个泛型类型同步 // 在call()方法内部，就可以对原始RDD中的每一个元素进行各种处理和计算，并返回一个新的元素 // 所有新的元素就会组成一个新的RDD JavaRDD<Integer> pair = numberRDD.map(new Function<Integer, Integer>() { @Override public Integer call(Integer i) throws Exception { return i*2; } }); pair.foreach(new VoidFunction<Integer>() { @Override public void call(Integer integer) throws Exception { System.out.println(integer); } }); sc.close(); } }
结果为：
- filter算子：过滤出集合中的偶数
package cn.spark.sparktest; import java.util.Arrays; import java.util.List; 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.VoidFunction; /** * transformation操作实战 * @author Administrator * */ public class transformationOpertion { public static void main(String[] args) { // map(); filter(); } public static void filter(){ // 创建SparkConf SparkConf conf = new SparkConf() .setAppName("filter") .setMaster("local"); // 创建JavaSparkContext JavaSparkContext sc = new JavaSparkContext(conf); // 构造集合 List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5,6,7,8,9); // 并行化集合，创建初始RDD JavaRDD<Integer> numberRDD = sc.parallelize(numbers); JavaRDD<Integer> evenNum = numberRDD.filter(new Function<Integer, Boolean>() { @Override public Boolean call(Integer i) throws Exception { return i % 2 ==0; } }); evenNum.foreach(new VoidFunction<Integer>() { @Override public void call(Integer integer) throws Exception { System.out.println(integer); } }); sc.close(); } }
测试：
- flatmap：将行拆分为单词
public static void flatmap(){ // 创建SparkConf SparkConf conf = new SparkConf() .setAppName("flatmap") .setMaster("local"); // 创建JavaSparkContext JavaSparkContext sc = new JavaSparkContext(conf); List<String> strs = Arrays.asList("hello spark, hello china","ni hao shij ie ","hello hadoop" ,"hello bigdata"); JavaRDD<String> strsRDD = sc.parallelize(strs); //flatmap算子 在Java中接收的参数是FlatMapFunction //需要自己定义它的第二个泛型，即 代表了新返回值得类型 //call方法 返回的类型 不是U 而知Interable<U> 这里的U也与第二个泛型类型相同 //flatmap其实就是 接收原始RDD中的每一个元素 返回可以返回多个元素 //封装在Iterable中 可以使用ArrayList等集合 JavaRDD<String> flat = strsRDD.flatMap(new FlatMapFunction<String, String>() { @Override public Iterable<String> call(String s) throws Exception { return Arrays.asList(s.split(" ")); } }); flat.foreach(new VoidFunction<String>() { @Override public void call(String s) throws Exception { System.out.println(s); } }); sc.close(); }
测试：
- groupByKey:将每个班级的成绩进行分组
public static void groupBykey(){ // 创建SparkConf SparkConf conf = new SparkConf() .setAppName("groupByKey") .setMaster("local"); // 创建JavaSparkContext JavaSparkContext sc = new JavaSparkContext(conf); // 模拟集合 List<Tuple2<String, Integer>> scoreList = Arrays.asList( new Tuple2<String, Integer>("class1", 80), new Tuple2<String, Integer>("class2", 75), new Tuple2<String, Integer>("class1", 90), new Tuple2<String, Integer>("class2", 65)); JavaPairRDD<String,Integer> scorrRDD = sc.parallelizePairs(scoreList); //groupByKey算子 返回的是JavaPairRDD //但是JavaPairRDD 泛型的第一个返回值不变 第二个为iterable类型 //也就是说安装key进行了分组 那么每个key可能对应多个value 多个key 聚合成了iterable //接下来 使用JavaPairRDD 进行处理 JavaPairRDD<String, Iterable<Integer>> result = scorrRDD.groupByKey(); result.foreach(new VoidFunction<Tuple2<String, Iterable<Integer>>>() { @Override public void call(Tuple2<String, Iterable<Integer>> s) throws Exception { System.out.println("class:" + s._1); Iterator<Integer> it = s._2.iterator(); while (it.hasNext()){ System.out.println(it.next()); } } }); sc.close(); } }
测试：
- reduceByKey:统计每个班级的总分
public static void reducebykey() { // 创建SparkConf SparkConf conf = new SparkConf() .setAppName("reducebykey") .setMaster("local"); // 创建JavaSparkContext JavaSparkContext sc = new JavaSparkContext(conf); // 模拟集合 List<Tuple2<String, Integer>> scoreList = Arrays.asList( new Tuple2<String, Integer>("class1", 80), new Tuple2<String, Integer>("class2", 75), new Tuple2<String, Integer>("class1", 90), new Tuple2<String, Integer>("class2", 65)); // 并行化集合，创建JavaPairRDD JavaPairRDD<String, Integer> scores = sc.parallelizePairs(scoreList); /* * reducebykey 算子接收的参数是Functaion2类型 有三个泛型参数 代表了三个值 * 第一二个代表了原始RDD元素中value的值的类型 * 因此会依次将第一二个传入 再将第三个传入 * 会自动定义两个类型变量 代表call方法传入的类型参数 * * */ JavaPairRDD<String, Integer> result = scores.reduceByKey(new Function2 <Integer, Integer, Integer>() { @Override public Integer call(Integer i, Integer j) throws Exception { return i + j; } }); result.foreach(new VoidFunction<Tuple2<String, Integer>>() { @Override public void call(Tuple2<String, Integer> s) throws Exception { System.out.println(s); } }); sc.close(); } }
测试：
- sortByKey:将学生分数进行排序
private static void sortByKey() {
// 创建SparkConf
SparkConf conf = new SparkConf()
.setAppName("sortByKey")
.setMaster("local");
// 创建JavaSparkContext
JavaSparkContext sc = new JavaSparkContext(conf);
// 模拟集合
List<Tuple2<Integer, String>> scoreList = Arrays.asList(
new Tuple2<Integer, String>(65, "leo"),
new Tuple2<Integer, String>(50, "tom"),
new Tuple2<Integer, String>(100, "marry"),
new Tuple2<Integer, String>(80, "jack"));
// 并行化集合，创建RDD
JavaPairRDD<Integer, String> scores = sc.parallelizePairs(scoreList);
// 对scores RDD执行sortByKey算子
// sortByKey其实就是根据key进行排序，可以手动指定升序，或者降序
// 返回的，还是JavaPairRDD，其中的元素内容，都是和原始的RDD一模一样的
// 但是就是RDD中的元素的顺序，不同了
JavaPairRDD<Integer, String> sortedScores = scores.sortByKey(false);
// 打印sortedScored RDD
sortedScores.foreach(new VoidFunction<Tuple2<Integer,String>>() {private static final long serialVersionUID = 1L;
@Override
public void call(Tuple2<Integer, String> t) throws Exception {
System.out.println(t._1 + ": " + t._2);
}
});
// 关闭JavaSparkContext
sc.close();
}
测试：
- join：打印每个学生的成绩
private static void join() {
// 创建SparkConf
SparkConf conf = new SparkConf()
.setAppName("join")
.setMaster("local");
// 创建JavaSparkContext
JavaSparkContext sc = new JavaSparkContext(conf);
// 模拟集合
List<Tuple2<Integer, String>> studentList = Arrays.asList(
new Tuple2<Integer, String>(1, "leo"),
new Tuple2<Integer, String>(2, "jack"),
new Tuple2<Integer, String>(3, "tom"));
List<Tuple2<Integer, Integer>> scoreList = Arrays.asList(
new Tuple2<Integer, Integer>(1, 100),
new Tuple2<Integer, Integer>(2, 90),
new Tuple2<Integer, Integer>(3, 60));
// 并行化两个RDD
JavaPairRDD<Integer, String> students = sc.parallelizePairs(studentList);
JavaPairRDD<Integer, Integer> scores = sc.parallelizePairs(scoreList);
// 使用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>> studentScores = students.join(scores);
// 打印studnetScores RDD
studentScores.foreach(
new VoidFunction<Tuple2<Integer,Tuple2<String,Integer>>>() {private static final long serialVersionUID = 1L;
@Override
public void call(Tuple2<Integer, Tuple2<String, 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
sc.close();
}
/**
* cogroup案例：打印学生成绩
*/
private static void cogroup() {
// 创建SparkConf
SparkConf conf = new SparkConf()
.setAppName("cogroup")
.setMaster("local");
// 创建JavaSparkContext
JavaSparkContext sc = new JavaSparkContext(conf);
// 模拟集合
List<Tuple2<Integer, String>> studentList = Arrays.asList(
new Tuple2<Integer, String>(1, "leo"),
new Tuple2<Integer, String>(2, "jack"),
new Tuple2<Integer, String>(3, "tom"));
List<Tuple2<Integer, Integer>> scoreList = 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> students = sc.parallelizePairs(studentList);
JavaPairRDD<Integer, Integer> scores = sc.parallelizePairs(scoreList);
// cogroup与join不同
// 相当于是，一个key join上的所有value，都给放到一个Iterable里面去了
JavaPairRDD<Integer, Tuple2<Iterable<String>, Iterable<Integer>>> studentScores =
students.cogroup(scores);
// 打印studnetScores RDD
studentScores.foreach(
new VoidFunction<Tuple2<Integer,Tuple2<Iterable<String>,Iterable<Integer>>>>() {private static final long serialVersionUID = 1L;
@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
sc.close();
}
}
测试：
扫一扫
377
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
