Spark RDD常用算子

Spark RDD常用算子

一、parallelize
调用SparkContext 的 parallelize()，将一个存在的集合，变成一个RDD，这种方式试用于学习spark和做一些spark的测试

scala版本
scala的parallelize有两个参数，第一个是一个Seq集合，第二个是分区数，如果没有则会是默认分区数
scala版本可以选择makeRDD替换parallelize，java版本则没有

val rdd = sc.parallelize(List("A","B","C"))
val rdd1 = sc.makeRDD(List("A","B","C"))

Java版本
java版本的参数则是一个List集合和分区数

JavaRDD<Tuple2<Integer,String>> rdd = sc.parallelize(Arrays.asList(
new Tuple2<>(1,"A"),
new Tuple2<>(2,"B"),
new Tuple2<>(3,"C")
));

二、textFile
从外部读取数据创建RDD，textFile支持分区，支持模糊匹配，可以读取多个路径，路径之间使用逗号隔开

scala版本

val rdd = sc.textFile("D:/text/*.txt,E:/text/sample.txt",2)

java版本

JavaRDD<String> rdd = sc.textFile("文件路径");

三、filter
过滤算子

scala版本

val conf = new SparkConf().setMaster("local[2]").setAppName("filterscala")
val sc=new SparkContext(conf)

val rdd = sc.textFile("in/sample.txt")
rdd.filter(_.contains("zks")).collect.foreach(println)

java版本

public static void main(String[] args) {
    SparkConf conf=new SparkConf().setMaster("local[*]").setAppName("filterJava");
    JavaSparkContext sc=new JavaSparkContext(conf);
public static void main(String[] args) {
    SparkConf conf=new SparkConf().setMaster("local[*]").setAppName("filterJava");
    JavaSparkContext sc=new JavaSparkContext(conf);

JavaRDD<String> lines=sc.textFile("in/sample.txt");
JavaRDD<String> filterRdd=lines.filter(new Function<String,Boolean>(){
    @override
    public Boolean call(String v) throws Exception{
        return v1.contains("zks");
    }
});

List<String> collect=filterRdd.collect();
for(String str:collect){
    System.out.println(str);
 }
}

四、map
map() 接收一个函数，把这个函数用于 RDD 中的每个元素，将函数的返回结果作为结果RDD编程
RDD 中对应元素的值 map是一对一的关系

示例：将每个元素变成元组
scala版本

def main(args: Array[String]): Unit = {
    val conf=new SparkConf().setMaster("local[2]").setAppName("mapScala")
    val sc=new SparkContext(conf)


    val lines =sc.textFile("in/sample.txt")  //装载文件
    val mapRdd =lines.map(x=>(x.split(" ")(0),1))
    mapRdd.collect.foreach(println)
}

java版本

SparkConf conf=new SparkConf().setMaster("local[2]").setAppName("mapJava");
JavaSparkContext sc=new JavaSparkContext(conf);

JavaRDD<String> lines=sc.textFile("in/sample.txt");
JavaRDD<Iterable> mapRdd=lines.map(new Function<String, Iterable>() {
    @Override
    public Iterable call(String v2) throws Exception {
        String[] split=v2.split(" ");
        return Arrays.asList(split);
    }
});

List<Iterable> collect= mapRdd.collect();
for (Iterable it : collect){
    Iterator iterator=it.iterator();
    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

五、flatMap
对某个元素生成多个元素，实现该功能的操作叫作 flatMap()
faltMap的函数应用于每一个元素，对于每一个元素返回的是多个元素组成的迭代器

示例：将数据切分成词
scala版本

def main(args: Array[String]): Unit = {
    val conf=new SparkConf().setMaster("local[2]").setAppName("mapdemo")
    val sc=new SparkContext(conf)

    val lines=sc.textFile("in/sample.txt")
    val flatMapRdd=lines.flatMap(_.split(" "))
    flatMapRdd.collect.foreach(println)
}

java版本，Spark2.0版本以上

SparkConf conf=new SparkConf().setMaster("local[2]").setAppName("flatMapJava");
JavaSparkContext sc=new JavaSparkContext(conf);

JavaRDD<String> lines=sc.textFile("in/sample.txt");
JavaRdd<String> flatMapRdd=lines.flatMap(new FlatMapFunction<String,String>(){
    @override
    public Iterator<String> call(String s)throws Exception{
        String[] split=s.split("\\s+");
        return Arrays.asList(split).iterator();
    }
});
    List<String> collect =flatMapRdd.collect();
    for(String s:collect){
        System.out.println(s);
    }

六、distinct
distinct用于去重，此方法涉及到混洗，操作开销很大
scala版本

val conf=new SparkConf().setMaster("local[2]").setAppName("distinctdemo")
val sc=new SparkContext(conf)

val rdd=sc.makeRDD(List("a","b","a","c"))
rdd.distinct.collect.foreach(println)

java版本

SparkConf conf=new SparkConf().setMaster("local[2]").setAppName("distinctJava");
JavaSparkContext sc=new JavaSparkContext(conf);

List<String> strings =Arrays.asList("a","b","a","b","c");
JavaRDD<String> strRdd=sc.parallelize(strings);
JavaRDD<String> distinctRdd=strRdd.distinct();
List<String> collect=ditinctRdd.collect();
for(String s:collect){
    System.out.println(s);
}

七、union
合并两个Rdd
scala版本

val rdd1=sc.makeRDD(List("a","b"))
val rdd2=sc.makeRDD(List("c","d"))
val unionRdd=rdd1.union(rdd2)
unionRdd.collect.foreach(println)

java版本

JavaRDD<String> rdd1=sc.parallelize(Arrays.asList("a","b"));
JavaRDD<String> rdd2=sc.parallelize(Arrays.asList("c","d"));
JavaRDD<String> unionRdd=rdd1.uinon(rdd2);
List<Stirng> collect=unionRdd.collect();
for(String s:collect){
    System.out.println(s)
}

八、intersection
返回两个RDD的交集，并且去重
intersection 需要混洗数据，比较浪费性能

scala版本

val rdd1=sc.makeRDD(List("aa","bb","cc"))
val rdd2=sc.makeRDD(List("cc","bb","dd"))
val intersectionRdd = rdd1.intersection(rdd2)
intersectionRdd.collect.foreach(println)

java版本

JavaRDD<String> rdd1=sc.parallelize(Arrays.asList("aa","bb","cc"));
JavaRDD<String> rdd2=sc.parallelize(Arrays.asList("cc","bb","dd"));
JavaRDD<String> intersectionRdd=rdd1.intersection(rdd2);
List<String> collect=intersection.collect();
for(String s:collect){
    System.out.println(s)
}

九、subtract
返回在RDD1中出现，但是不在RDD2中出现的元素，不去重

scala版本

val rdd1=sc.makeRDD(List("aa","bb","cc"))
val rdd2=sc.makeRDD(List("cc","bb","dd"))
val subtractRdd = rdd1.subtract(rdd2)
subtractRdd.collect.foreach(println)

java版本

JavaRDD<String> rdd1=sc.parallelize(Arrays.asList("aa","bb","cc"));
JavaRDD<String> rdd2=sc.parallelize(Arrays.asList("cc","bb","dd"));
JavaRDD<String> subtractRdd=rdd1.subtract(rdd2);
List<String> collect=subtract.collect();
for(String s:collect){
    System.out.println(s)
}

十、cartesian
返回Rdd1和Rdd2的笛卡儿积，这个开销非常大，慎用

scala版本

val rdd1 = sc.makeRDD(List("1","2","3"))
val rdd2 = sc.makeRDD(List("a","b","c"))
val cartesianRdd=rdd1.cartesian(rdd2)
cartesian.collect.foreach(println)

java版本

JavaRDD<String> rdd1 = sc.parallelize(Arrays.asList("1","2","3"));
JavaRDD<String> rdd2 = sc.parallelize(Arrays.asList("a","b","c"));
JavaRDD<String,String> cartesianRdd=rdd1.cartesian(rdd2);
List<Tuple2<String,String>> collect=cartesianRdd.collect();
for(Tuple2 t:collect){
    System.out.print(t);
}

十一、mapToPair
将每一行的第一个单词作为键，1 作为value创建pairRDD
scala版本
scala没有mapToPair，使用map就能完成

val conf=new SparkConf().setMaster("local[2]").setAppName("maptopair")
val sc=new SparkContext(conf)
val lines=sc.textFile("D:/text/sample.txt")
val pairs = lines.map(x=>(x.split(" ")(0),1))
pairs.collect.foreach(println)

java版本

SparkConf conf=new SparkConf().setMaster("local[2]").setAppName("mapToPairJava");
JavaSparkContext sc = new JavaSparkContext(conf);

JavaRDD<String> lines=sc.textFile("D:/text/sample.txt");
JavaPairRDD<String,Integer> pairRdd=lines.mapToPair(new PairFunction<String,String,Integer>(){
    @override
    public Tuple2<String,Integer> call(String s) throws Exception{
        String[] split=s.split(" ");
        String key = split[0];
        return new Tuple2<>(key,1);
    }
});
List<Tuple2<String,Integer>> collect=pairRdd.collect();
for(Tuple2