一、transformation开发实战
1、map: 将集合中每个元素乘以2
使用map算子，将集合中的每个元素都乘以2 map算子，是对任何类型的RDD，都可以调用的，在Java中，map算子接收的参数是Function对象 创建的Function对象，一定会让你设置第二个泛型参数，这个泛型类型，就是返回的新元素的类型 同时call()方法的返回类型，也必须与第二个泛型类型同步 在call()方法内部，就可以对原始RDD中的 每一个元素进行各种处理和计算，并返回一个新的元素 所有新的元素，就会组成一个新的RDD ----------java 实现---------- package cn.spark.study.core; 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 bcqf * */ public class TransformationOperation { 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
//public interface Function<T1, R> extends Serializable {
//public R call(T1 v1) throws Exception;
//}
JavaRDD<Integer> multipleNumberRDD = numberRDD.map(new Function<Integer, Integer>() { private static final long serialVersionUID = 1L; //传入ca11（）方法的，就是1，2，3，4，5 //返回的就是2，4，6，8，10 @Override public Integer call(Integer v1) throws Exception { // TODO Auto-generated method stub return v1 * 2; } }); //打印新的RDD
//VoidFunction：A function with no return value
//public interface VoidFunction<T> extends Serializable {
//public void call(T t) throws Exception;
//}
multipleNumberRDD.foreach(new VoidFunction<Integer>() { private static final long serialVersionUID = 1L; @Override public void call(Integer t) throws Exception { System.out.println(t); } }); //关闭JavaSparkContext sc.close(); } } ----------scala 实现---------- package cn.spark.study.core import org.apache.spark.SparkConf import org.apache.spark.SparkContext object TransformationOperation { def main(args: Array[String]) { map() } def map() { val conf = new SparkConf().setAppName("map").setMaster("local") val sc = new SparkContext(conf) val numbers = Array(1, 2, 3, 4, 5) val numberRDD = sc.parallelize(numbers, 1) val multipleNumberRDD = numberRDD.map { num => num * 2} multipleNumberRDD.foreach {num => println(num)} } }
2、filter：过滤出集合中的偶数
-------------java实现------------
/**
* filter算子案例：过滤出集合中的偶数
*/
private 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, 10);
// 并行化集合，创建初始RDD
JavaRDD<Integer> numberRDD = sc.parallelize(numbers);
// 对初始RDD执行filter算子，过滤出其中的偶数
// filter算子，传入的也是Function，其他的使用注意点，实际上和map是一样的
// 但是唯一的不同，就是call()方法的返回类型是Boolean
// 每一个初始RDD中的元素，都会传入call()方法，此时你可以执行各种自定义的计算逻辑
// 来判断这个元素是否是你想要的
// 如果你想在新的RDD中保留这个元素，那么就返回true，否则，不想保留这个元素，返回false
JavaRDD<Integer> evenNumberRDD = numberRDD.filter(new Function<Integer, Boolean>() {
private static final long serialVersionUID = 1L;
@Override
public Boolean call(Integer v1) throws Exception {
return v1 % 2 == 0;
}
});
// 打印新的RDD
evenNumberRDD.foreach(new VoidFunction<Integer>() {
private static final long serialVersionUID = 1L;
@Override
public void call(Integer t) throws Exception {
System.out.println(t);
}
});
// 关闭JavaSparkContext
sc.close();
}
//结果
2
4
6
8
10
-------------scala实现------------ def filter() { val conf = new SparkConf().setAppName("filter").setMaster("local") val sc = new SparkContext(conf) val numbers = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) val numberRDD = sc.parallelize(numbers, 1) val evenNumberRDD = numberRDD.filter { num => num % 2 == 0 } evenNumberRDD.foreach { num => println(num)} }
3、flatMap：将行拆分为单词
----------java实现-----------
private static void flatMap() {
// 创建SparkConf
SparkConf conf = new SparkConf().setAppName("flatMap").setMaster("local");
// 创建JavaSparkContext
JavaSparkContext sc = new JavaSparkContext(conf);
//构造集合
List<String> lineList = Arrays.asList("hello you", "hello me", "hello word");
// 并行化集合，创建RDD
JavaRDD<String> lines = sc.parallelize(lineList);
// 对RDD执行flatMap算子，将每一行文本，拆分为多个单词
// flatMap算子，在Java中，接收的参数是FlatMapFunction
// 我们需要自己定义FlatMapFunction的第一个泛型类型，即，代表了返回的新元素的类型
// call()方法，返回的类型，不是U，而是Iterable<U>,这里的U也与第二个泛型类型相同
// flatMap其实就是，接收原始RDD中的每个元素，并进行各种逻辑的计算和处理，返回可以返回多个元素
// 多个元素，即封装在Iterable集合中，可以使用ArrayList等集合
// 新的RDD中，即封装了所有的新元素，也就是说，新的RDD大小一定是大于等于原始RDD的大小
// 从每个输入记录返回零个或多个输出记录的函数
//public interface FlatMapFunction<T, R> extends Serializable {
//public Iterable<R> call(T t) throws Exception;
//}
JavaRDD<String> words = lines.flatMap(new FlatMapFunction<String, String>() { private static final long serialVersionUID = 1L; @Override public Iterable<String> call(String t) throws Exception { return Arrays.asList(t.split(" ")); } }); // 打印新的RDD words.foreach(new VoidFunction<String>() { private static final long serialVersionUID = 1L; @Override public void call(String t) throws Exception { System.out.println(t); } }); // 关闭JavaSparkContext sc.close(); } //结果
hello
you
hello
me
hello
word
-----------scala实现------------ def flatMap() { val conf = new SparkConf().setAppName("flatMap").setMaster("local") val sc = new SparkContext(conf) val lineArray = Array("hello you", "hello me", "hello word") val lines = sc.parallelize(lineArray, 1) val words = lines.flatMap {line => line.split(" ")} words.foreach { word => println(word)} }
4、groupByKey：将每个班级的成绩进行分组
---------java实现---------
private 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> score = sc.parallelizePairs(scoreList);
//针对scores RDD，执行groupByKey算子，对每个班级的成绩进行分组
JavaPairRDD<String, Iterable<Integer>> groupedScores = score.groupByKey();
groupedScores.foreach(new VoidFunction<Tuple2<String,Iterable<Integer>>>() {
private static final long serialVersionUID = 1L;
@Override
public void call(Tuple2<String, Iterable<Integer>> t) throws Exception {
System.out.println("class: " + t._1);
Iterator<Integer> ite = t._2.iterator();
while(ite.hasNext()) {
System.out.println(ite.next());
}
System.out.println("======================");
}
});
//关闭JavaSparkContext
sc.close();
}
//结果
class: class1
80
90
======================
class: class2
75
65
======================
---------scala实现--------- def groupByKey() { val conf = new SparkConf().setAppName("groupByKey").setMaster("local") val sc = new SparkContext(conf) val scoreList = Array(Tuple2("class1", 80), Tuple2("class2", 75), Tuple2("class1", 90), Tuple2("class2", 60)) val scores = sc.parallelize(scoreList, 1) val groupedScores = scores.groupByKey() groupedScores.foreach(score => { println(score._1); score._2.foreach { singleScore => println(singleScore)}; println("==================") }) }
5、reduceByKey：统计每个班级的总分
--------java实现---------
private 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<String, Integer> scores = sc.parallelizePairs(scoreList);
// 针对scoreRDD，执行reduceByKey算子
// reduceByKey,接收的参数是Function2类型，它有三个泛型参数，实际上代表了三个值
// 第一个泛型类型和第二个泛型类型，代表了原始RDD中的元素的value的类型
// 因此对每个key进行reduce，都会依次将第一个、第二个value传入，将返回的值再与第三个value传入
// 因此此处，会自动定义两个类型参数类型，代表call()方法的两个传入参数的类型
// 第三个类型参数，代表了每次reduce操作返回的值的类型，默认也是与原始RDD的value类型相同的
// reduceByKey算子返回的RDD，还是JavaPairRDD<Key,Value>
//一个双参数函数，接收类型为T1和T2的参数，并返回一个R
//public interface Function2<T1, T2, R> extends Serializable {
//public R call(T1 v1, T2 v2) throws Exception;
//}
JavaPairRDD<String, Integer> totalScores = scores.reduceByKey(new Function2<Integer, Integer, Integer>() { private static final long serialVersionUID = 1L; //对每个key，都会将其value，依次传入ca11方法 //从而聚合出每个key对应的一个value //然后，将每个key对应的一个value，组合成一个Tuple2，作为新RDD的元素 @Override public Integer call(Integer v1, Integer v2) throws Exception { return v1 + v2; } }); // 打印totalScores RDD totalScores.foreach(new VoidFunction<Tuple2<String,Integer>>() { private static final long serialVersionUID = 1L; @Override public void call(Tuple2<String, Integer> t) throws Exception { System.out.println(t._1 + ": " + t._2); } }); //关闭JavaSparkContext sc.close(); } //结果
class1: 170
class2: 140
--------scala实现--------- def reduceByKey() { val conf = new SparkConf().setAppName("groupByKey").setMaster("local") val sc = new SparkContext(conf) val scoreList = Array(Tuple2("class1", 80), Tuple2("class2", 75), Tuple2("class1", 90), Tuple2("class2", 60)) val scores = sc.parallelize(scoreList, 1) val totalScores = scores.reduceByKey(_ + _) totalScores.foreach(classScore => println(classScore._1 + ": " + classScore._2)) }
6、sortByKey：将学生分数进行排序
--------java实现---------
private static void sortByKey() {
//创建SparkConf
SparkConf conf = new SparkConf().setAppName("reduceByKey").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);
//针对scoreRDD，执行sortByKey算子; false: 降序
// sortByKey其实就是根据key进行排序，可以手动指定升序，或者降序
// 返回的，还是JavaPairRDD，其中元素内容，都是和原始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();
}
//结果
100: marry
80: jack
65: leo
50: tom
--------scala实现--------- def sortByKey() { val conf = new SparkConf().setAppName("groupByKey").setMaster("local") val sc = new SparkContext(conf) val scoreList = Array(Tuple2(65, "leo"), Tuple2(50, "tom"), Tuple2(100, "marry"), Tuple2(85, "jack")) val scores = sc.parallelize(scoreList, 1) val sortedScores = scores.sortByKey(false) sortedScores.foreach(studentScore => println(studentScore._1 + ": " + studentScore)) }
7、join和cogroup：打印每个学生的成绩
join：
--------java实现--------
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算子关联两个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);
//打印studentScores 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();
}
//结果
student id: 1
student name: leo
student score: 100
-----------------
student id: 3
student name: tom
student score: 60
-----------------
student id: 2
student name: jack
student score: 90
-----------------
--------scala实现--------- def join() { val conf = new SparkConf().setAppName("groupByKey").setMaster("local") val sc = new SparkContext(conf) val studentList = Array(Tuple2(1, "leo"), Tuple2(2, "jack"), Tuple2(3, "tom")) val scoreList = Array(Tuple2(1, 100),Tuple2(2, 90), Tuple2(3, 60)) val students = sc.parallelize(studentList); val scores = sc.parallelize(scoreList); val studentScores = students.join(scores) studentScores.foreach(studentScore => { println("student id:" + studentScore._1) println("student name:" + studentScore._2._1) println("student score:" + studentScore._2._1) println("==================") }) }
cogroup：
-------java实现--------
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关联两个RDD
// 相当于是，一个key join上的所有value，都给放到一个Iterable里面去了
// cogroup，不太好讲解，希望通过动手编写我们的案例，仔细体会其中的奥妙
JavaPairRDD<Integer, Tuple2<Iterable<String>, Iterable<Integer>>> studentScores = students.cogroup(scores);
//打印studentScores 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();
}
//结果
student id: 1
student name: [leo]
student score: [100, 70]
-----------------
student id: 3
student name: [tom]
student score: [60, 50]
-----------------
student id: 2
student name: [jack]
student score: [90, 80]
-----------------
二、action实战
1、reduce：累加
---------java实现---------
private static void reduce() {
// 创建SparkConf和JavaSparkContext
SparkConf conf = new SparkConf()
.setAppName("reduce")
.setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
// 有一个集合，里面有1到10,10个数字，现在要对10个数字进行累加
List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
JavaRDD<Integer> numbers = sc.parallelize(numberList);
// 使用reduce操作对集合中的数字进行累加
// reduce操作的原理：
// 首先将第一个和第二个元素，传入call()方法，进行计算，会获取一个结果，比如1 + 2 = 3
// 接着将该结果与下一个元素传入call()方法，进行计算，比如3 + 3 = 6
// 以此类推
// 所以reduce操作的本质，就是聚合，将多个元素聚合成一个元素
int sum = numbers.reduce(new Function2<Integer, Integer, Integer>() {
private static final long serialVersionUID = 1L;
@Override
public Integer call(Integer v1, Integer v2) throws Exception {
return v1 + v2;
}
});
System.out.println("sum：" + sum);
// 关闭JavaSparkContext
sc.close();
}
--------scala实现---------
def reduce() {
val conf = new SparkConf().setAppName("reduce").setMaster("local")
val sc = new SparkContext(conf)
val numberArray = Array(1,2,3,4,5,6,7,8,9,10)
val numbers = sc.parallelize(numberArray, 1)
val sum = numbers.reduce(_ + _)
println("sum: " + sum)
}
2、collect
--------java实现---------
private static void collect() {
// 创建SparkConf和JavaSparkContext
SparkConf conf = new SparkConf()
.setAppName("collect")
.setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
//有一个集合，里面有1到10,10个数字，
List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
JavaRDD<Integer> numbers = sc.parallelize(numberList);
//使用map操作将集合中所有数字乘以2
JavaRDD<Integer> doubleNumbers = numbers.map(new Function<Integer, Integer>() {
private static final long serialVersionUID = 1L;
@Override
public Integer call(Integer v1) throws Exception {
// TODO Auto-generated method stub
return v1 * 2;
}
});
// 不用foreach action操作，在远程集群上遍历rdd中的元素,而使用collect操作，将分布在远程集群上的doubleNumbers RDD的数据拉取到本地
// 这种方式，一般不建议使用，因为如果rdd中的数据量比较大的话，比如超过1万条
// 那么性能会比较差，因为要从远程走大量的网络传输，将数据获取到本地
// 此外，除了性能差，还可能在rdd中数据量特别大的情况下，发生oom异常，内存溢出
// 因此，通常，还是推荐使用foreach action操作，来对最终的rdd元素进行处理
List<Integer> doubleNumberList = doubleNumbers.collect();
for(Integer num : doubleNumberList) {
System.out.println(num);
}
// 关闭JavaSparkContext
sc.close();
}
-------scala实现--------
def collect() {
val conf = new SparkConf().setAppName("collect").setMaster("local")
val sc = new SparkContext(conf)
val numberArray = Array(1,2,3,4,5,6,7,8,9,10)
val numbers = sc.parallelize(numberArray, 1)
val doubleNumbers = numbers.map { num => num * 2 }
val doubleNumberArray = doubleNumbers.collect()
for(num <- doubleNumberArray) {
println(num)
}
}
3、count
------java实现-------
private static void count() {
// 创建SparkConf和JavaSparkContext
SparkConf conf = new SparkConf()
.setAppName("count")
.setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
//有一个集合，里面有1到10,10个数字，
List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
JavaRDD<Integer> numbers = sc.parallelize(numberList);
//对rdd使用count操作，统计它有多少个元素
long count = numbers.count();
System.out.println(count);
// 关闭JavaSparkContext
sc.close();
}
-----scala实现------
def count() {
val conf = new SparkConf().setAppName("count").setMaster("local")
val sc = new SparkContext(conf)
val numberArray = Array(1,2,3,4,5,6,7,8,9,10)
val numbers = sc.parallelize(numberArray, 1)
val count = numbers.count()
println(count)
}
4、take
--------java实现-------
private static void take() {
// 创建SparkConf和JavaSparkContext
SparkConf conf = new SparkConf()
.setAppName("take")
.setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
//有一个集合，里面有1到10,10个数字，
List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
JavaRDD<Integer> numbers = sc.parallelize(numberList);
//take操作，与col1ect类似，也是从远程集群上，获取rdd的数据
//但是co1lect是获取rdd的所有数据，take只是获取前n个数据
List<Integer> top3Numbers = numbers.take(3);
for(Integer num : top3Numbers) {
System.out.println(num);
}
// 关闭JavaSparkContext
sc.close();
}
-------scala实现----------
def take() {
val conf = new SparkConf().setAppName("take").setMaster("local")
val sc = new SparkContext(conf)
val numberArray = Array(1,2,3,4,5,6,7,8,9,10)
val numbers = sc.parallelize(numberArray, 1)
val top3Numbers = numbers.take(3)
for(num <- top3Numbers) {
println(num)
}
}
5、saveAsTextFile
---------java实现-----------
private static void saveAsTextFile() {
// 创建SparkConf和JavaSparkContext
SparkConf conf = new SparkConf()
.setAppName("saveAsTextFile");
JavaSparkContext sc = new JavaSparkContext(conf);
//有一个集合，里面有1到10,10个数字，
List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
JavaRDD<Integer> numbers = sc.parallelize(numberList);
//使用map操作将集合中左右数字乘以2
JavaRDD<Integer> doubleNumbers = numbers.map(new Function<Integer, Integer>() {
private static final long serialVersionUID = 1L;
@Override
public Integer call(Integer v1) throws Exception {
// TODO Auto-generated method stub
return v1 * 2;
}
});
// 直接将rdd中的数据，保存在HFDS文件中
// 但是要注意，我们这里只能指定文件夹，也就是目录
// doubleNumbers.saveAsTextFile("hdfs://spark1:9000/double_number.txt");
// 那么实际上，会保存为目录中的/double_number.txt/part-00000文件
doubleNumbers.saveAsTextFile("hdfs://spark1:9000/double_number.txt");
// 关闭JavaSparkContext
sc.close();
}
##打包--上传--运行
[root@spark1 java]# cat saveASTextFile.sh #运行脚本
/usr/local/spark/bin/spark-submit
--class cn.spark.study.core.ActionOperation
--num-executors 3
--driver-memory 100m
--executor-memory 100m
--executor-cores 3
/usr/local/spark-study/java/saprk-study-java-0.0.1-SNAPSHOT-jar-with-dependencies.jar
6、countByKey
------java实现-------
private static void countByKey() {
// 创建SparkConf
SparkConf conf = new SparkConf()
.setAppName("countByKey")
.setMaster("local");
// 创建JavaSparkContext
JavaSparkContext sc = new JavaSparkContext(conf);
// 模拟集合
List<Tuple2<String, String>> scoreList = Arrays.asList(
new Tuple2<String, String>("class1", "leo"),
new Tuple2<String, String>("class2", "jack"),
new Tuple2<String, String>("class1", "marry"),
new Tuple2<String, String>("class2", "tom"),
new Tuple2<String, String>("class2", "david"));
// 并行化集合，创建JavaPairRDD
JavaPairRDD<String, String> students = sc.parallelizePairs(scoreList);
// 对rdd应用countByKey操作，统计每个班级的学生人数，也就是统计每个key对应的元素个数
// 这就是countByKey的作用
// countByKey返回的类型，直接就是Map<String, Object>
Map<String, Object> studentCounts = students.countByKey();
for(Map.Entry<String, Object> studentCount : studentCounts.entrySet()) {
System.out.println(studentCount.getKey() + ": " + studentCount.getValue());
}
// 关闭JavaSparkContext
sc.close();
}
//结果
class1: 2
class2: 3
--------scala实现---------- def countByKey() { val conf = new SparkConf() .setAppName("countByKey") .setMaster("local") val sc = new SparkContext(conf) val studentList = Array(Tuple2("class1", "leo"), Tuple2("class2", "jack"), Tuple2("class1", "tom"), Tuple2("class2", "jen"), Tuple2("class2", "marry")) val students = sc.parallelize(studentList, 1) val studentCounts = students.countByKey() println(studentCounts) }
7、foreach
foreach，遍历RDD的元素，在远程集群上执行
----java实现-----
public static void foreach() { // 创建SparkConf SparkConf sparkConf = new SparkConf().setAppName("foreachJava").setMaster("local"); // 创建JavaSparkContext JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf); // 有一个集合，里面有1到10,10个数字， // 创建集合 List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // 并行化集合，创建初始化RDD JavaRDD<Integer> numsRDD = javaSparkContext.parallelize(nums); numsRDD.foreach(new VoidFunction<Integer>() { @Override public void call(Integer integer) throws Exception { System.out.println("integer = " + integer); } }); // 关闭javaSparkContext javaSparkContext.close(); }