Spark RDD算子（六） aggregate，collect，count，first，fold， reduce，take，top，takeOrdered

aggregate

def aggregate[U](zeroValue: U)(seqOp: (U, Int) => U,combOp: (U, U) => U)(implicit evidence$31: scala.reflect.ClassTag[U]): U

• zeroValue：初始值，根据需求进行设定
• seqOp：是对每个分区进行聚合，每个分区聚合结果作为 combOp 的输入；
• combOp：对分区聚合结果再次进行聚合

scala版本

将分区数设置为2，运行以下代码

val rdd1 = sc.parallelize(List(1,2,3,4))
println(rdd1.aggregate(10)((x, y) => {
  println("seq:" + x, y); x + y
}, (x, y) => {
  println("comb:" + x, y); x + y
}))

结果如下图所示，对于初始值zeroValue，会在每个分区中参与一次seqOp运算。1和2在同一分区，3和4在同一分区，按照seqOp规则计算出两个分区的结果，然后按照combOp的规则计算不同分区的结果

java版本

设置三个分区

JavaRDD<Integer> rdd1 = sc.parallelize(Arrays.asList(1, 2, 3, 4));
// seqOp
Function2<Integer, Integer, Integer> seqOP = new Function2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer v1, Integer v2) throws Exception {
        System.out.println("seq"+v1+","+v2);
        return v1 + v2;
    }
};
// combOp
Function2<Integer, Integer, Integer> combOP = new Function2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer v1, Integer v2) throws Exception {
        System.out.println("comb"+v1+","+v2);
        return v1 + v2;
    }
};
System.out.println(rdd1.aggregate(10, seqOP, combOP));

collect

收集一个弹性分布式数据集的所有元素到一个数组中

scala版本

val rdd = sc.parallelize(List(1,2,3,4))
rdd.collect()

java版本

JavaRDD<Integer> rdd = sc.parallelize(Arrays.asList(1, 2, 3, 3));
List<Integer> collect = rdd.collect();

count

返回RDD中的元素数量

scala版本

val rdd = sc.parallelize(List(1,2,3,4))
rdd.count

java版本

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

first

返回第一个元素

scala版本

val rdd = sc.parallelize(List(1, 2, 1, 3, 3, 3, 4))
rdd.first

java版本

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

fold

提供了初始值num,每个分区计算时，先要合这个初始值进行运算, 然后分区之间运算时还会再次进行fold

scala版本

val rdd = sc.parallelize(List(1, 2, 3, 4))
rdd.fold(10)((x,y)=>{println(x,y);x+y})

java版本

三个分区运行以下代码

JavaRDD<Integer> rdd = sc.parallelize(Arrays.asList(1, 2, 3, 4));
Integer fold = rdd.fold(10, new Function2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer v1, Integer v2) throws Exception {
        System.out.println(v1 + "," + v2);
        return v1 + v2;
    }
});
System.out.println(fold);

reduce

与fold的功能类似，不同是没有初始值

scala版本

val rdd = sc.parallelize(List(1, 2, 3, 4))
rdd.reduce((x,y)=>{println(x,y);x+y})

java版本

JavaRDD<Integer> rdd = sc.parallelize(Arrays.asList(1, 2, 3, 4));
Integer reduceResult = rdd.reduce(new Function2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer v1, Integer v2) throws Exception {
        System.out.println("(" + v1 + "," + v2 + ")");
        return v1 + v2;
    }
});
System.out.println(reduceResult);

take

返回第n个元素

scala版本

val rdd = sc.parallelize(List(1, 2, 3, 4))
rdd.take(3)

java版本

JavaRDD<Integer> rdd = sc.parallelize(Arrays.asList(1, 2, 3, 4));
List<Integer> takeResult = rdd.take(3);
System.out.println(takeResult);

top

按照默认（倒序）或自定义顺序取前n个值，默认功能取前n个最大值

scala版本

val rdd = sc.parallelize(List(8,5,2,7,3,4))
rdd.top(3)
// 自定义排序规则，正序
rdd.top(3)(implicitly[Ordering[Int]].reverse)

java版本

JavaRDD<Integer> rdd2 = sc.parallelize(Arrays.asList(8, 5, 2, 7, 3, 4));
List<Integer> topResult = rdd2.top(2);
System.out.println(topResult);

takeOrdered

takeOrdered和top类似，只不过以和top相反的顺序返回元素。

scala版本

val rdd = sc.parallelize(List(8,5,2,7,3,4))
rdd.takeOrdered(3)
// 自定义排序规则，倒序
rdd.takeOrdered(3)(implicitly[Ordering[Int]].reverse)

java版本

JavaRDD<Integer> rdd2 = sc.parallelize(Arrays.asList(8, 5, 2, 7, 3, 4));
List<Integer> takeOrderedResult = rdd2.takeOrdered(2);
System.out.println(takeOrderedResult);