Spark之常用RDD算子（java版本与scala版本对比）

最新推荐文章于 2024-06-21 00:59:15 发布

子清.

最新推荐文章于 2024-06-21 00:59:15 发布

阅读量1k

点赞数 2

分类专栏： # SparkCore 文章标签： spark

本文链接：https://blog.youkuaiyun.com/zmzdmx/article/details/109565914

版权

parallelize

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

scala版本

def parallelize[T](seq: Seq[T], numSlices: Int = defaultParallelism)(implicit arg0: ClassTag[T]): RDD[T]

- 第一个参数一是一个 Seq集合

- 第二个参数是分区数

- 返回的是RDD[T]

val rdd: RDD[Int] = sc.parallelize(List(1,2,3,4,5,6,7))

java版本

def parallelize[T](list : java.util.List[T], numSlices : scala.Int) : org.apache.spark.api.java.JavaRDD[T] = {
    /* compiled code */ }

- 第一个参数是一个List集合

- 第二个参数是一个分区，可以默认

- 返回的是一个JavaRDD[T]

java版本只能接收List的集合

JavaRDD<Integer> rdd = sc.parallelize(Arrays.asList(1, 2, 3, 4, 5, 6));

makeRDD

只有scala版本的才有makeRDD

def makeRDD[T](seq : scala.Seq[T], numSlices : scala.Int = {
    /* compiled code */ })

跟parallelize类似

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6,7))

textFile

调用SparkContext.textFile()方法，从外部存储中读取数据来创建 RDD

例如在我本地input下有个word.txt文件，文件随便写了点内容，我需要将里面的内容读取出来创建RDD

scala版本

val rdd: RDD[String] = sc.textFile("in/word.txt")

java版本

JavaRDD<String> stringJavaRDD = sc.textFile("in/word.txt");

注: textFile支持分区，支持模式匹配，例如把in目录下.txt的给转换成RDD

var lines = sc.textFile("in/*.txt")

多个路径可以使用逗号分隔，例如

var lines = sc.textFile("dir1,dir2",3)

filter

举例，在sample.txt 文件的内容如下

aa bb cc aa aa aa dd dd ee ee ee ee 
ff aa bb zks
ee kks
ee  zz zks

我要将包含zks的行的内容给找出来

scala版本

val rdd: RDD[String] = sc.textFile("in/sample.txt")
val rdd2: RDD[String] = rdd.filter(x=>x.contains("zks"))
rdd2.foreach(println)

java版本

JavaRDD<String> rdd2 = sc.textFile("in/sample.txt");
JavaRDD<String> filterRdd = rdd2.filter(new Function<String, Boolean>() {
   
    @Override
    public Boolean call(String v1) throws Exception {
   
        return v1.contains("zks");
    }
});
List<String> collect3 = filterRdd.collect();
for (String s : collect3) {
   
    System.out.println(s);
}

map

map() 接收一个函数，把这个函数用于 RDD 中的每个元素，将函数的返回结果作为结果RDD编程

RDD 中对应元素的值 map是一对一的关系

scala版本

//读取数据
scala> val lines = sc.textFile("F:\\sparktest\\sample.txt")
//用map，对于每一行数据，按照空格分割成一个一个数组，然后返回的是一对一的关系
scala> var mapRDD = lines.map(line => line.split("\\s+"))
---------------输出-----------
res0: Array[Array[String]] = Array(Array(aa, bb, cc, aa, aa, aa, dd, dd, ee, ee, ee, ee), Array(ff, aa, bb, zks), Array(ee, kks), Array(ee, zz, zks))

//读取第一个元素
scala> mapRDD.first
---输出----
res1: Array[String] = Array(aa, bb, cc, aa, aa, aa, dd, dd, ee, ee, ee, ee)

java版本

JavaRDD<String> stringJavaRDD = sc.textFile("in/sample.txt");
JavaRDD<Iterable> mapRdd = stringJavaRDD.map(new Function<String, Iterable>() {
   
    @Override
    public Iterable call(String v1) throws Exception {
   
        String[] split = v1.split(" ");
        return Arrays.asList(split);
    }
});
List<Iterable> collect = mapRdd.collect();
for (Iterable iterable : collect) {
   
    Iterator iterator = iterable.iterator();
    while (iterator.hasNext()) System.out.println(iterator.next());
}

System.out.println(mapRdd.first());

flatMap

有时候，我们希望对某个元素生成多个元素，实现该功能的操作叫作 flatMap()

faltMap的函数应用于每一个元素，对于每一个元素返回的是多个元素组成的迭代器(想要了解更多，请参考scala的flatMap和map用法)

例如我们将数据切分为单词

scala版本

val rdd: RDD[String] = sc.textFile("in/sample.txt")
rdd.flatMap(x=>x.split(" ")).foreach(println)

java版本，spark2.0以下

    JavaRDD<String> lines = sc.textFile("/in/sample.txt");
    JavaRDD<String> flatMapRDD = lines.flatMap(new FlatMapFunction<String, String>() {
   
        @Override
        public Iterable<String> call(String s) throws Exception {
   
            String[] split = s.split("\\s+");
            return Arrays.asList(split);
        }
    });
    //输出第一个
    System.out.println(flatMapRDD.first());
------------输出----------
aa

java版本，spark2.0以上

spark2.0以上，对flatMap的方法有所修改，就是flatMap中的Iterator和Iteratable的小区别

JavaRDD<String> flatMapRdd = stringJavaRDD.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用于去重，我们生成的RDD可能有重复的元素，使用distinct方法可以去掉重复的元素, 不过此方法涉及到混洗，操作开销很大
scala版本

val rdd: RDD[Int] = sc.parallelize(List(1,1,1,2,3,4,5,6))
val rdd2: RDD[Int] = rdd.distinct()
rdd2.collect.foreach(println)

java版本

JavaRDD<String> javaRDD = sc.parallelize(Arrays.asList("aa", "aa", "cc", "dd"));
JavaRDD<String> distinctRdd = javaRDD.distinct();
List<String> collect = distinctRdd.collect();
for (String s : collect) {
   
    System.out.println(s);
}

union

两个RDD进行合并

scala版本

val rdd1: RDD[Int] = sc.parallelize(List(1,1,1,1))
val rdd2: RDD[Int] = sc.parallelize(List(2,2,2,2))
val rdd3: RDD[Int] = rdd1.union(rdd2)
rdd3.collect.foreach(println)

java版本

JavaRDD<String> javaRDD = sc.parallelize(Arrays.asList("aa", "aa", "cc", "dd"));
JavaRDD<String> javaRDD2 = sc.parallelize(Arrays.asList("aa", "aa", "cc", "dd"));
JavaRDD<String> unionRdd = javaRDD.union(javaRDD2);
List<String> collect = unionRdd.collect();
for (String s : collect) {
   
    System.out.print(s+",");
}

intersection

RDD1.intersection(RDD2) 返回两个RDD的交集，并且去重

intersection 需要混洗数据，比较浪费性能

scala版本

val rdd1: RDD[String] = sc.parallelize(List("aa","aa","bb","cc"))
val rdd2: RDD[String] = sc.parallelize(List("aa","aa","bb","ff"))
val intersectionRdd: RDD[String] = rdd1.intersection(rdd2)
intersectionRdd.collect.foreach(println)

java版本

JavaRDD<String> javaRDD = sc.parallelize(Arrays.asList("aa", "aa", "cc", "dd"));
JavaRDD<String> javaRDD2 = sc.parallelize(Arrays.asList("aa", "aa", "cc", "ff"));
List<String> collect = javaRDD.intersection(javaRDD2).collect();
for (String s : collect) {
   
    System.out.print(s+",");
}

subtract

RDD1.subtract(RDD2),返回在RDD1中出现，但是不在RDD2中出现的元素，不去重

scala版本

val rdd1: RDD[String] = sc.parallelize(List("aa","aa","bb","cc"))
val rdd2: RDD[String] = sc.parallelize(List("aa","aa","bb","ff"))
val intersectionRdd: RDD[String] = rdd1.subtract(rdd2)
intersectionRdd.collect.foreach(println)

java版本

JavaRDD<String> javaRDD = sc.parallelize(Arrays.asList("aa", "aa", "cc", "dd"));
JavaRDD<String> javaRDD2 = sc.parallelize(Arrays.asList("aa", "aa", "cc", "ff"));
List<String> collect = javaRDD.subtract(javaRDD2).collect();
for (String s : collect) {
   
    System.out.print(s+",");
}

cartesian

RDD1.cartesian(RDD2) 返回RDD1和RDD2的笛卡儿积，这个开销非常大

scala版本

val rdd1: RDD[String] = sc.parallelize(List("aa","aa","bb","cc"))
val rdd2: RDD[String] = sc.parallelize(List("aa","aa","bb","ff"))
val rdd3: RDD[(String, String)] = rdd1.cartesian(rdd2)
rdd3.collect.foreach(println)

java版本

JavaRDD<String> javaRDD = sc.parallelize(Arrays.asList("1","2","3"));
JavaRDD<String> javaRDD2 = sc.parallelize(Arrays.asList("aa", "aa", "cc", "ff"));
List<Tuple2<String, String>> collect = javaRDD.cartesian(javaRDD2).collect();
for (Tuple2<String, String> tuple2 : collect) {
   
    System.out.println(tuple2);
}

mapToPair

将每一行的第一个单词作为键，1 作为value创建pairRDD

scala版本

scala是没有mapToPair函数的，scala版本只需要map就可以了

val rdd: RDD[String] = sc.textFile("in/sample.txt")
val rdd2: RDD[(String, Int)] = rdd.map(x=>(x.split(" ")(0),1))
rdd2.collect.foreach(println)

java版本

JavaRDD<String> javaRDD = sc.textFile("in/sample.txt");
JavaPairRDD<String, Integer> mapToPair = javaRDD.mapToPair(new PairFunction<String, String, Integer>() {
   
    @Override
    public Tuple2<String, Integer> call(String s) throws Exception {
   
        String key = s.split(" ")[0];
        return new Tuple2<>(key, 1);
    }
});
List<Tuple2<String, Integer>> collect = mapToPair.collect();
for (Tuple2<String, Integer> tuple2 : collect) {
   
    System.out.println(tuple2);
}

flatMapToPair

类似于xxx连接 mapToPair是一对一，一个元素返回一个元素，而flatMapToPair可以一个元素返回多个，相当于先flatMap,在mapToPair

例子: 将每一行的第一个单词作为键，1 作为value

scala版本

val rdd1: RDD[String] = sc.textFile("in/sample.txt")
val flatRdd: RDD[String] = rdd1.flatMap(x=>x.split(" "))
val pairs: RDD[(String, Int)] = flatRdd.map(x=>(x,1))
pairs.collect.foreach(println)

java版本 spark2.0以下

JavaPairRDD<String, Integer> wordPairRDD = lines.flatMapToPair(new PairFlatMapFunction<String, String, Integer>() {
   
            @Override
            public Iterable<Tuple2<String, Integer>> call(String s) throws Exception {
   
                ArrayList<Tuple2<String, Integer>> tpLists = new ArrayList<Tuple2<String, Integer>>();
                String[] split = s.split("\\s+");
                for (int i = 0; i <split.length ; i++) {
   
                    Tuple2 tp = new Tuple2<String,Integer>(split[i], 1);
                    tpLists.add(tp);
                }
            return tpLists;
            }
        });

java版本 spark2.0以上

主要是iterator和iteratable的一些区别

JavaRDD<String> javaRDD = sc.textFile("in/sample.txt");
JavaPairRDD<String, Integer> flatMapToPair = javaRDD.flatMapToPair(new PairFlatMapFunction<String, String, Integer>() {
   
    @Override
    public Iterator<Tuple2<String, Integer>> call(String s) throws Exception {
   
        ArrayList<Tuple2<String, Integer>> list = new ArrayList<>();
        String[] split = s.split(" ");
        for (int i = 0; i < split.length; i++) {
   
            String key = split[i];
            Tuple2<String, Integer> tuple2 = new Tuple2<>(key, 1);
            list.add(tuple2);
        }
        return list.iterator();
    }
});
List<Tuple2<String, Integer>> collect = flatMapToPair.collect();
for (Tuple2<String, Integer> tuple2 : collect) {
   
    System.out.println("key "+tuple2._1+" value "+tuple2._2);
}

combineByKey

聚合数据一般在集中式数据比较方便，如果涉及到分布式的数据集，该如何去实现呢。这里介绍一下combineByKey, 这个是各种聚集操作的鼻祖，应该要好好了解一下,参考scala API

简要介绍

def combineByKey[C](createCombiner: (V) => C,  
                    mergeValue: (C, V) => C,   
                    mergeCombiners: (C, C) => C): RD

createCombiner: combineByKey() 会遍历分区中的所有元素，因此每个元素的键要么还没有遇到过，要么就和之前的某个元素的键相同。如果这是一个新的元素， combineByKey() 会使用一个叫作 createCombiner() 的函数来创建那个键对应的累加器的初始值
mergeValue: 如果这是一个在处理当前分区之前已经遇到的键，它会使用 mergeValue() 方法将该键的累加器对应的当前值与这个新的值进行合并
mergeCombiners: 由于每个分区都是独立处理的，因此对于同一个键可以有多个累加器。如果有两个或者更多的分区都有对应同一个键的累加器，就需要使用用户提供的 mergeCombiners() 方法将各
个分区的结果进行合并。

计算学生平均成绩例子

这里举一个计算学生平均成绩的例子,例子参考至https://www.edureka.co/blog/apache-spark-combinebykey-explained, github源码我对此进行了解析

创建一个学生成绩说明的类

case class ScoreDetail(studentName:String,subject:String,score:Float)

下面是一些测试数据，加载测试数据集合 key = Students name and value = ScoreDetail instance

val scores = List(
  ScoreDetail("xiaoming", "Math", 98),
  ScoreDetail("xiaoming", "English", 88),
  ScoreDetail("wangwu", "Math", 75),
  ScoreDetail("wangwu", "English", 78),
  ScoreDetail("lihua", "Math", 90),
  ScoreDetail("lihua", "English", 80),
  ScoreDetail("zhangsan", "Math", 91),
  ScoreDetail("zhangsan", "English", 80))

将集合转换成二元组，也可以理解成转换成一个map, 利用了for 和 yield的组合

val scoresWithKey = for {
    i <- scores } yield (i.studentName, i)

创建RDD, 并且指定三个分区

val scoresWithKeyRDD: RDD[(String, ScoreDetail)] = sc.parallelize(scoresWithKey).partitionBy(new HashPartitioner(3)).cache()

输出打印一下各个分区的长度和各个分区的一些数据

scoresWithKeyRDD.foreachPartition(partitions=>{
   
      partitions.foreach(x=>println(x._1,x._2.subject,x._2.score))
    })

聚合求平均值让后打印

val avgScoresRdd: RDD[(String, Float)] = scoresWithKeyRDD.combineByKey(
  (x: ScoreDetail) => (x.score, 1),
  (acc: (Float, Int), x: ScoreDetail) => (acc._1 + x.score, acc._2 + 1),
  (acc1: (Float, Int), acc2: (Float, Int)) => (acc1._1 + acc2._1, acc1._2 + acc2._2)
).map({
    case (key, value) => (key, value._1 / value._2) })

avgScoresRdd.collect.foreach(println)

解释一下scoresWithKeyRDD.combineByKey

createCombiner: (x: ScoreDetail) => (x.score, 1)

这是第一次遇到zhangsan，创建一个函数，把map中的value转成另外一个类型，这里是把(zhangsan,(ScoreDetail类))转换成(zhangsan,(91,1))

mergeValue: (acc: (Float, Int), x: ScoreDetail) => (acc._1 + x.score, acc._2 + 1) 再次碰到张三，就把这两个合并, 这里是将(zhangsan,(91,1)) 这种类型和 (zhangsan,(ScoreDetail类))这种类型合并，合并成了(zhangsan,(171,2))

mergeCombiners (acc1: (Float, Int), acc2: (Float, Int)) 这个是将多个分区中的zhangsan的数据进行合并，我们这里zhansan在同一个分区，这个地方就没有用上

java版本

ScoreDetail类

package nj.zb.CombineByKey;

import java.io.Serializable;


public class ScoreDetailsJava implements Serializable {

最低0.47元/天解锁文章

Spark之常用RDD算子（java版本与scala版本对比）

文章目录

parallelize

makeRDD

textFile

filter

map

flatMap

distinct

union

intersection

subtract

cartesian

mapToPair

flatMapToPair

combineByKey