spark RDD算子（九）之基本的Action操作 first, take, collect, count, countByValue, reduce, aggregate, fold,top_在spark 中 ,first() 方法属于什么操作?

first

返回第一个元素
scala

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

val rdd1 = sc.parallelize(List(1,2,3,4,5))
//注意，此为scala公共代码
1
2
3
4
5

println(rdd1.first())

//结果	1
1
2
3

java

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

JavaRDD<Integer> rdd1 = sc.parallelize(Arrays.asList(1, 2, 3, 4, 5));
//注意，此为java公共代码
1
2
3
4
5

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

//结果	1
1
2
3

take

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

println(rdd1.take(3).mkString(","))

//结果	1,2,3
1
2
3

java

System.out.println(rdd1.take(3));

//结果	[1, 2, 3]
1
2
3

collect

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

println(rdd1.collect().mkString(","))

//结果	1,2,3,4,5
1
2
3

java

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

//结果	[1, 2, 3, 4, 5]
1
2
3

count

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

println(rdd1.count())

//结果	5
1
2
3

java

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

//结果	5
1
2
3

countByValue

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

println(rdd1.countByValue())

//结果	Map(5 -> 1, 1 -> 1, 2 -> 1, 3 -> 1, 4 -> 1)
1
2
3

java

Map<Integer, Long> countByValueMap = rdd1.countByValue();
for (Integer key :
        countByValueMap.keySet()) {
    System.out.println(key+" : "+countByValueMap.get(key));
}

/*结果
5 : 1
1 : 1
2 : 1
3 : 1
4 : 1
*/
1
2
3
4
5
6
7
8
9
10
11
12
13

reduce

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

println(rdd1.reduce((x,y)=>x+y))

//结果	15
1
2
3

java

Function2<Integer, Integer, Integer> function2 = new Function2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer v1, Integer v2) throws Exception {
        return v1 + v2;
    }
};

System.out.println(rdd1.reduce(function2));

//结果	15
1
2
3
4
5
6
7
8
9
10

aggregate

和 reduce() 相 似， 但是通常返回不同类型的函数，一般不用这个函数
注意，初始值会在各个分区内都操作和执行一次。
scala

println(rdd1.aggregate(10)(_ + _, _ + _))

//结果	185
1
2
3

java

Function2<Integer, Integer, Integer> function2 = new Function2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer v1, Integer v2) throws Exception {
        return v1 + v2;
    }
};

System.out.println(rdd1.aggregate(10, function2, function2));

//结果	185
1
2
3
4
5
6
7
8
9
10

fold

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

println(rdd1.fold(10)(_ + _))

//结果	185
1
2
3

java

Function2<Integer, Integer, Integer> function2 = new Function2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer v1, Integer v2) throws Exception {
        return v1 + v2;
    }
};

System.out.println(rdd1.fold(10, function2));

//结果	185
1
2
3
4
5
6
7
8
9
10

top

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

println(rdd1.top(2).mkString(","))

//结果	5,4
1
2
3

java

System.out.println(rdd1.top(2));

//结果	[5,4]
1
2
3

takeOrdered

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

println(rdd1.takeOrdered(2).mkString(","))

//结果	1，2
1
2
3

java

System.out.println(rdd1.takeOrdered(2));

//结果	1，2
1
2
3

foreach

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

rdd1.foreach(print)

//结果	12345
1
2
3

java

rdd1.foreach(new VoidFunction<Integer>() {
    @Override
    public void call(Integer v) throws Exception {
        System.out.print(v);
    }
});

//结果	12345
1
2
3
4
5
6
7
8