11.19 spark RDD算子（二）

spark RDD算子 键值对分组操作 groupByKey，cogroup

groupByKey

groupByKey会将RDD[key,value] 按照相同的key进行分组，形成RDD[key,Iterable[value]]的形式， 有点类似于sql中的groupby，例如类似于mysql中的group_concat

scala版：

nameScoreRDD.groupByKey().collect.foreach(println)

java版：

List<Tuple2<String, Iterable<Float>>> collect = scoreMapPairRDD.groupByKey().collect();
for (Tuple2<String, Iterable<Float>> tuple2 : collect) {
//    System.out.println(tuple2);
    Iterator<Float> iterator = tuple2._2.iterator();
    while (iterator.hasNext()){
        System.out.println(tuple2._1 + " " + iterator.next());
    }
}

cogroup

cogroup()对多个共享同一个键的RDD进行分组

RDD1.cogroup(RDD2) 会将RDD1和RDD2按照相同的key进行分组，得到(key,RDD[key,Iterable[value1],Iterable[value2]])的形式
cogroup也可以多个进行分组
例如RDD1.cogroup(RDD2,RDD3,…RDDN), 可以得到(key,Iterable[value1],Iterable[value2],Iterable[value3],…,Iterable[valueN])

scala版：

val scoreDetail = sc.parallelize(List(("xiaoming",95),("xiaoming",90),("lihua",95),("lihua",98),("xiaofeng",97)))
val scoreDetai2 = sc.parallelize(List(("xiaoming",65),("lihua",63),("lihua",62),("xiaofeng",67)))
val scoreDetai3 = sc.parallelize(List(("xiaoming",25),("xiaoming",15),("lihua",35),("lihua",28),("xiaofeng",36)))
scoreDetail.cogroup(scoreDetai2,scoreDetai3)

java版：

JavaRDD<ScoreDetailJava> scoresRDD = sc.parallelize(Arrays.asList(
        new ScoreDetailJava("zhangsan", "Math", 90f),
        new ScoreDetailJava("lisi", "English", 97f),
        new ScoreDetailJava("zhaoliu", "Math", 39f)
));

JavaPairRDD<String, Float> scoresPairRDD = scoresRDD.mapToPair(new PairFunction<ScoreDetailJava, String, Float>() {
    @Override
    public Tuple2<String, Float> call(ScoreDetailJava scoreDetailJava) throws Exception {
        return new Tuple2<>(scoreDetailJava.name, scoreDetailJava.score);
    }
});
JavaPairRDD<String, Tuple2<Iterable<Float>, Iterable<Float>>> cogroupRDD = scoreMapPairRDD.cogroup(scoresPairRDD);
Map<String, Tuple2<Iterable<Float>, Iterable<Float>>> stringTuple2Map = cogroupRDD.collectAsMap();
Set<String> name = stringTuple2Map.keySet();
for (String s : name) {
    System.out.println(s + "," + stringTuple2Map.get(s));
}

spark RDD算子 键值对关联操作 subtractByKey，join，fullOuterJoin，rightOuterJoin，LeftOuterJoin

subtractByKey

类似于subtrac，删掉 RDD 中键与 other RDD 中的键相同的元素

scala版：

rdd1.subtractByKey(rdd2).collect.foreach(println)

java版：

Map<Integer, Integer> subtractByKeyRDD = rddPair1.subtractByKey(rddPair2).collectAsMap();
for (Integer integer : subtractByKeyRDD.keySet()) {
    System.out.println(integer + " " + subtractByKeyRDD.get(integer));
}

join

RDD1.join(RDD2)
可以把RDD1,RDD2中的相同的key给连接起来，类似于sql中的join操作

scala版：

rdd1.join(rdd2).collect.foreach(println)

java版：

Map<Integer, Tuple2<Integer, Integer>> joinRDD = rddPair1.join(rddPair2).collectAsMap();
for (Integer integer : joinRDD.keySet()) {
    System.out.println(integer + " " + joinRDD.get(integer));
}

leftOuterJoin

对两个RDD进行连接操作，类似于SQL中的左外连接

scala版：

rdd1.leftOuterJoin(rdd2).collect.foreach(println)

java版：

Map<Integer, Tuple2<Integer, Optional<Integer>>> leftOuterJoinRDD = rddPair1.leftOuterJoin(rddPair2).collectAsMap();
for (Integer integer : leftOuterJoinRDD.keySet()) {
    System.out.println(integer + " " + leftOuterJoinRDD.get(integer));
}

rightOuterJoin

对两个RDD进行连接操作，类似于SQL中的右外连接，存在的话，value用的Some, 不存在用的None

scala版：

rdd1.rightOuterJoin(rdd2).collect.foreach(println)

java版：

Map<Integer, Tuple2<Optional<Integer>, Integer>> rightOuterJoinRDD = rddPair1.rightOuterJoin(rddPair2).collectAsMap();
for (Integer integer : rightOuterJoinRDD.keySet()) {
    System.out.println(integer + " " + rightOuterJoinRDD.get(integer));
}

spark 基本的Action操作 first，take，collect，count，countByValue，reduce，aggregate，fold，top

first

返回第一个元素

scala版：

val rdd1: RDD[(Int, Int)] = sc.makeRDD(Array((1,30),(3,21),(2,29),(1,28)))
val rdd2: RDD[(Int, Int)] = sc.makeRDD(Array((3,33),(2,22),(3,29),(2,28)))
System.out.println(rdd1.first());

java版：

JavaRDD<Tuple2<Integer, Integer>> rdd1 = sc.parallelize(Arrays.asList(
        new Tuple2<Integer, Integer>(1, 30),
        new Tuple2<Integer, Integer>(3, 21),
        new Tuple2<Integer, Integer>(2, 29),
        new Tuple2<Integer, Integer>(1, 28)));
JavaRDD<Tuple2<Integer, Integer>> rdd2 = sc.parallelize(Arrays.asList(
        new Tuple2<Integer, Integer>(3, 33),
        new Tuple2<Integer, Integer>(2, 22),
        new Tuple2<Integer, Integer>(3, 29),
        new Tuple2<Integer, Integer>(2, 28)));
System.out.println(rdd1.first());

take

rdd.take(n)返回第n个元素

scala版：

for (elem <- rdd1.take(2)) {println(elem)}

java版：

for (Tuple2<Integer, Integer> integerIntegerTuple2 : rdd1.take(3)) {
    System.out.println(integerIntegerTuple2);
}

collect

rdd.collect() 返回 RDD 中的所有元素

scala版：

rdd1.collect.foreach(println)

java版：

List<Tuple2<Integer, Integer>> collect = rdd1.collect();
System.out.println(collect);

count

rdd.count() 返回 RDD 中的元素个数

scala版：

println(rdd1.count())

java版：

System.out.println(rdd1.count());

countByValue

各元素在 RDD 中出现的次数 返回{(key1,次数),(key2,次数),…(keyn,次数)}

scala版：

println(rdd1.countByValue())

java版：

System.out.println(rdd1.countByValue());

reduce

rdd.reduce(func)并行整合RDD中所有数据， 类似于是scala中集合的reduce

scala版：

val arr: RDD[Int] = sc.parallelize(Array(1,2,23,5,6,7))
println(arr.reduce(_+_))

java版：

JavaRDD<Integer> arr = sc.parallelize(Arrays.asList(1, 2, 23, 5, 6, 7));
Integer reduceRDD = arr.reduce(new Function2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer v1, Integer v2) throws Exception {
        return v1 + v2;
    }
});
System.out.println(reduceRDD);

aggregate

和 reduce() 相 似， 但 是 通 常返回不同类型的函数 一般不用这个函数

scala版：

println(arr.aggregate(3)(_+_,_+_))

java版：

System.out.println(arr.aggregate(7, new Function2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer v1, Integer v2) throws Exception {
        return v1 + v2;
    }
}, new Function2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer v1, Integer v2) throws Exception {
        return v1 + v2;
    }
}));

fold

rdd.fold(num)(func) 一般不用这个函数
和 reduce() 一 样， 但是提供了初始值num,每个元素计算时，先要合这个初始值进行折叠, 注意，这里会按照每个分区进行fold，然后分区之间还会再次进行fold
需要提供初始值

scala版：

println(arr.fold(4)(_+_))

java版：

System.out.println(arr.fold(3, new Function2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer v1, Integer v2) throws Exception {
        return v1 + v2;
    }
}));

top

rdd.top(n)
按照降序的或者指定的排序规则，返回前n个元素

scala版：

for (elem <- arr.top(4)) {println(elem)}

java版：

for (Integer integer : arr.top(3)) {
    System.out.println(integer);
}

takeOrdered

rdd.take(n)
对RDD元素进行升序排序,取出前n个元素并返回，也可以自定义比较器（这里不介绍），类似于top的相反的方法

scala版：

for (elem <- arr.takeOrdered(3)) {println(elem)}

java版：

for (Integer integer : arr.takeOrdered(3)) {
    System.out.println(integer);
}

foreach

对RDD中的每一个元素使用给定函数

scala版：

arr.foreach(println(_))

java版：

arr.foreach(new VoidFunction<Integer>() {
    @Override
    public void call(Integer integer) throws Exception {
        System.out.println(integer);
    }
});

spark RDD算子 Action操作countByKey，collectAsMap

countByKey

def countByKey(): Map[K, Long]
以RDD{(1, 2),(2,4),(2,5), (3, 4),(3,5), (3, 6)}为例 rdd.countByKey会返回{(1,1),(2,2),(3,3)}

scala版：

rdd1.countByKey().foreach(println)

java版：

System.out.println(rddPair1.countByKey());

collectAsMap

将pair类型(键值对类型)的RDD转换成map

scala版：

rdd1.collectAsMap().foreach(println)

java版：

Map<Integer, Integer> collectAsMapRDD = rddPair1.collectAsMap();
Set<Integer> integers = collectAsMapRDD.keySet();
for (Integer integer : integers) {
    System.out.println(integer + "," + collectAsMapRDD.get(integer));
}