在學習Spark前，建議先正確理解spark，可以參考：正確理解spark
本篇對JavaRDD基本的action api進行了詳細的描述
先定義兩個Comparator實現，一個是實現升序，一個是實現降序
//升序排序比較器
private static class AscComparator implements Comparator<Integer>, Serializable {
@Override
public int compare(java.lang.Integer o1, java.lang.Integer o2) {
return o1 - o2;
}
}
//降序排序比較器
private static class DescComparator implements Comparator<Integer>, Serializable {
@Override
public int compare(java.lang.Integer o1, java.lang.Integer o2) {
return o2 - o1;
}
}再定義一個RDD：
JavaRDD<Integer> listRDD = sc.parallelize(Arrays.asList(1, 2, 4, 3, 3, 6), 2);
一、collect、take、top、first
//結果： [1, 2, 4, 3, 3, 6] 將RDD的所有數據收集到driver端來，用於小數據或者實驗，
// 對大數據量的RDD進行collect會出現driver端內存溢出
System.out.println("collect = " + listRDD.collect());
//結果：[1, 2] 將RDD前面兩個元素收集到java端
//take的原理大致爲：先看看RDD第一個分區的元素夠不夠我們想take的數量
//不夠的話再根據剩餘的需要take的數據量來估算需要掃描多少個分區的數據，直到take到了我們想要的數據個數爲止
System.out.println("take(2) = " + listRDD.take(2));
//結果：[6, 4] 取RDD升序的最大的兩個元素
System.out.println("top(2) = " + listRDD.top(2));
//結果：[1, 2] 取RDD降序的最大的兩個元素(即取RDD最小的兩個元素)
System.out.println("DescComparator top(2) = " + listRDD.top(2, new DescComparator()));
//結果：1 其底層實現就是take(1)
System.out.println("first = " + listRDD.first());二、min、max
//結果：1。 按照升序取最小值，就是RDD的最小值
System.out.println("min = " + listRDD.min(new AscComparator()));
//結果：6 按照降序取最小值，就是RDD的最大值
System.out.println("min = " + listRDD.min(new DescComparator()));
//結果：6 按照升序取最大值，就是RDD的最大值
System.out.println("max = " + listRDD.max(new AscComparator()));
//結果：1 按照降序取最大值，就是RDD的最小值
System.out.println("max = " + listRDD.max(new DescComparator()));min和max的底層是用reduce api來實現的，下面是僞代碼
min() == reduce((x, y) => if (x <= y) x else y) max() == redcue((x, y) => if (x >= y) x else y)
對於reduce api我們見下面的講解
三、takeOrdered
//結果：[1, 2] 返回該RDD最小的兩個元素
System.out.println("takeOrdered(2) = " + listRDD.takeOrdered(2));
//結果：[1, 2] 返回RDD按照升序的前面兩個元素，即返回該RDD最小的兩個元素
System.out.println("takeOrdered(2) = " + listRDD.takeOrdered(2, new AscComparator()));
//結果：[6, 4] 返回RDD按照降序的前面兩個元素，即返回該RDD最大的兩個元素
System.out.println("takeOrdered(2) = " + listRDD.takeOrdered(2, new DescComparator()));四、foreach和foreachPartition
foreach是對RDD每一個元素應用自定義的函數，而foreachPartition是對RDD的每一個partition應用自定義的函數，使用時需要注意下面的建議
先定義一個比較耗時的操作：
public static Integer getInitNumber(String source) {
System.out.println("get init number from " + source + ", may be take much time........");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 1;
}listRDD.foreach(new VoidFunction<Integer>() {
@Override
public void call(Integer element) throws Exception {
//這個性能太差，遍歷每一個元素的時候都需要調用比較耗時的getInitNumber
//建議採用foreachPartition來代替foreach操作
Integer initNumber = getInitNumber("foreach");
System.out.println((element + initNumber) + "=========");
}
});
listRDD.foreachPartition(new VoidFunction<Iterator<Integer>>() {
@Override
public void call(Iterator<Integer> integerIterator) throws Exception {
//和foreach api的功能是一樣，只不過一個是將函數應用到每一條記錄，這個是將函數應用到每一個partition
//如果有一個比較耗時的操作，只需要每一分區執行一次這個操作就行，則用這個函數
//這個耗時的操作可以是連接數據庫等操作，不需要計算每一條時候去連接數據庫，一個分區只需連接一次就行
Integer initNumber = getInitNumber("foreach");
while (integerIterator.hasNext()) {
System.out.println((integerIterator.next() + initNumber) + "=========");
}
}
});五、reduce 和 treeReduce
Integer reduceResult = listRDD.reduce(new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer ele1, Integer ele2) throws Exception {
return ele1 + ele2;
}
});
//結果：19
System.out.println("reduceResult = " + reduceResult);
Integer treeReduceResult = listRDD.treeReduce(new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer integer, Integer integer2) throws Exception {
return integer + integer2;
}
}, 3); //這個3表示做3次聚合才計算出結果
//結果：19
System.out.println("treeReduceResult = " + treeReduceResult);它們倆的結果是一樣的，但是執行流程不一樣，如下流程：
如果分區數太多的話，使用treeReduce做多次聚合，可以提高性能，如下：
六、fold
fold其實和reduce的功能類似，只不過fold多了一個初始值而已
//和reduce的功能類似，只不過是在計算每一個分區的時候需要加上初始值0，最後再將每一個分區計算出來的值相加再加上這個初始值
Integer foldResult = listRDD.fold(0, new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer integer, Integer integer2) throws Exception {
return integer + integer2;
}
});
//結果：19
System.out.println("foldResult = " + foldResult);七、aggregate 和 treeAggregate
//先初始化一個我們想要的返回的數據類型的初始值
//然後在每一個分區對每一個元素應用函數一(acc, value) => (acc._1 + value, acc._2 + 1)進行聚合
//最後將每一個分區生成的數據應用函數(acc1, acc2) => (acc1._1 + acc2._1, acc1._2 + acc2._2)進行聚合
Tuple2 aggregateResult = listRDD.aggregate(new Tuple2<Integer, Integer>(0, 0),
new Function2<Tuple2<Integer, Integer>, Integer, Tuple2<Integer, Integer>>() {
@Override
public Tuple2<Integer, Integer> call(Tuple2<Integer, Integer> acc, Integer integer) throws Exception {
return new Tuple2<>(acc._1 + integer, acc._2 + 1);
}
}, new Function2<Tuple2<Integer, Integer>, Tuple2<Integer, Integer>, Tuple2<Integer, Integer>>() {
@Override
public Tuple2<Integer, Integer> call(Tuple2<Integer, Integer> acc1, Tuple2<Integer, Integer> acc2) throws Exception {
return new Tuple2<>(acc1._1 + acc2._1, acc1._2 + acc2._2);
}
});
//結果：(19,6)
System.out.println("aggregateResult = " + aggregateResult);
Tuple2 treeAggregateResult = listRDD.treeAggregate(new Tuple2<Integer, Integer>(0, 0),
new Function2<Tuple2<Integer, Integer>, Integer, Tuple2<Integer, Integer>>() {
@Override
public Tuple2<Integer, Integer> call(Tuple2<Integer, Integer> acc, Integer integer) throws Exception {
return new Tuple2<>(acc._1 + integer, acc._2 + 1);
}
}, new Function2<Tuple2<Integer, Integer>, Tuple2<Integer, Integer>, Tuple2<Integer, Integer>>() {
@Override
public Tuple2<Integer, Integer> call(Tuple2<Integer, Integer> acc1, Tuple2<Integer, Integer> acc2) throws Exception {
return new Tuple2<>(acc1._1 + acc2._1, acc1._2 + acc2._2);
}
}, 2);
//結果：(19,6)
System.out.println("treeAggregateResult = " + treeAggregateResult);兩者的結果是一致的，只不過執行流程不一樣，如下是aggregate的執行流程：
如果RDD的分區數非常多的話，建議使用treeAggregate，如下是treeAggregate的執行流程：
aggregate和treeAggregate的比較：
1: aggregate在combine上的操作，時間複雜度爲O(n). treeAggregate的時間複雜度爲O(lgn)。
n表示分區數
2: aggregate把數據全部拿到driver端，存在內存溢出的風險。treeAggregate則不會。
3:aggregate 比 treeAggregate在最後結果的reduce操作時，多使用了一次初始值
對於以上api的原理層面的講解，可以參考spark core RDD api原理詳解,因爲用文字講清楚原理性的東西是一件比較困難的事情，看了後記得也不深入