大数据Saprk----spark的RDD使用文档

first Codec

**public class Friend {
	public static void main(String[] args){
		System.out.println("BigData加QQ群：947967114");
	}
}**

1、算子分类
Spark 算子类似于java中的方法、scala中的函数，spark算子的底层源码都是scala代码，加载源码后可以进行查看。大方向来说，算子大致可以分为以下两类

1、Transformation：操作是延迟计算的，也就是说从一个RDD（算子） 转换生成另一个 RDD（算子） 的转换操作不是马上执行，需要等到有 Action 操作的时候才会真正触发运算。
2、Action：会触发 Spark 提交作业（Job），并将数据输出 Spark系统。

从小方向来说，Spark 算子大致可以分为以下三类:

1、Value数据类型的Transformation算子。
2、Key-Value数据类型的Transfromation算子。
3、Action算子
1.1 Value数据类型的Transformation算子
类型 算子
输入分区与输出分区一对一型 map、flatMap、mapPartitions、glom
输入分区与输出分区多对一型 union、cartesian
输入分区与输出分区多对多型 groupBy
输出分区为输入分区子集型 filter、distinct、subtract、sample、takeSample
Cache型 cache、persist
1.2 Key-Value数据类型的Transfromation算子
类型 算子
输入分区与输出分区一对一 mapValues
多对一RDD combineByKey、reduceByKey、partitionBy
两个RDD聚集 Cogroup
连接 join、leftOutJoin、rightOutJoin
1.3 Action算子
类型 算子
无输出 foreach
HDFS saveAsTextFile、saveAsObjectFile
Scala集合和数据类型 collect、collectAsMap、reduceByKeyLocally、lookup、count、top、reduce、fold、aggregate
2、spark算子之Transformation
说明：以下代码全部在eclipse开发环境中实现
2.1 map
2.1.1 概述
语法结构（scala）：
def map[U: ClassTag](f: T => U): RDD[U]
说明：
将原来RDD的每个数据项通过map中的用户自定义函数f映射转变为一个新的元素
2.1.3 Scala示例
val conf=new SparkConf().setAppName(“Msh”).setMaster(“local”)
val sc=new SparkContext(conf)
def main(args: Array[String]): Unit = {
val data=sc.parallelize(1 to 9) //加载数据
def mapDoubleFunc(a:Int):(Int,Int)=(a,a*2) //自定义函数
val mapresult=data.map(mapDoubleFunc) //map处理传递自己定义的函数
mapresult.foreach(println) //循环打印输出
val data3=sc.parallelize(Array((“A”,1),(“A”,2),(“A”,3),(“B”,1),(“B”,2),(“C”,1)),3)
//定义第二个数。
data3.mapValues(x=>x to 3).foreach(println)//适应mapValues输出，x=>x to 3的意义是，每来一组键值对，把它的值都输出本身到3的范围，如”A”,1输出为A （1,2,3）。
执行结果：

2.2 filter
2.2.1 概述
语法（scala）：
def filter(f: T => Boolean): RDD[T]
说明：
对元素进行过滤，对每个元素应用f函数，返回值为true的元素在RDD中保留，返回为false的将过滤掉
2.2.2Scala示例
val conf=new SparkConf().setAppName(“Msh”).setMaster(“local”)
val sc=new SparkContext(conf)
def main(args: Array[String]): Unit = {

val datas = Array(1, 2, 3, 7, 4, 5, 8)
val dataRdd=sc.parallelize(datas)
dataRdd.cache()

val result=dataRdd.filter(_<3)

val resData=result.cache()
val perData=result.persist()
 resData.foreach { x => println(x) }

2.3 flatMap
2.3.1 简述
语法（scala）：
def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]
说明：
与map类似，但每个输入的RDD成员可以产生0或多个输出成员

2.3.3 Scala示例
val conf=new SparkConf().setAppName(“Msh”).setMaster(“local”)
val sc=new SparkContext(conf)
def main(args: Array[String]): Unit = {

val data = Array(“aa,bb,cc”,“cxf,spring,struts2”
,“java,C++,javaScript”);
val result=sc.parallelize(data).flatMap(lint=>lint.split(","))
result.foreach(x=>println(x))
}
2.4 mapPartitions
2.4.1 概述
语法（scala）：
def mapPartitions[U: ClassTag](
f: Iterator[T] => Iterator[U],
preservesPartitioning: Boolean = false): RDD[U]
说明：
与Map类似，但map中的func作用的是RDD中的每个元素，而mapPartitions中的func作用的对象是RDD的一整个分区。所以func的类型是Iterator => Iterator，其中T是输入RDD元素的类型。preservesPartitioning表示是否保留输入函数的partitioner，默认false。
2.4.3 Scala示例
import scala.collection.mutable.ArrayBuffer//注意要导包
val names = Array(“张三1”, “李四1”, “王五1”, “张三2”, “李四2”
,“王五2”, “张三3”, “李四3”, “王五3”, “张三4”);
sc.parallelize(names, 3).mapPartitions(n => {
val result = ArrayBufferString
while (n.hasNext) {
result.append(n.next())
}
result.iterator
},false).foreach(println)
}
2.5 mapPartitionsWithIndex
2.5.1 概述
语法（scala）：
def mapPartitionsWithIndex[U: ClassTag](
f: (Int, Iterator[T]) => Iterator[U],
preservesPartitioning: Boolean = false): RDD[U]
说明：
与mapPartitions类似，但输入会多提供一个整数表示分区的编号，所以func的类型是(Int, Iterator) => Iterator，多了一个Int
2.5.3 Scala示例
val names = Array(“张三1”, “李四1”, “王五1”, “张三2”, “李四2”
,“王五2”, “张三3”, “李四3”, “王五3”, “张三4”);
sc.parallelize(names, 3)
.mapPartitionsWithIndex(
(m, n) => {
val result = ArrayBufferString
while (n.hasNext) {
result.append(“分区索引:” + m + “\t” + n.next())
}
result.iterator
}
).foreach(println)
加载本地文件，分割，过滤出大于2的值，分区输出
2.6 sample
2.6.1 概述
语法（scala）：
def sample(
withReplacement: Boolean,
fraction: Double,
seed: Long = Utils.random.nextLong): RDD[T]
说明：
对RDD进行抽样，其中参数withReplacement为true时表示抽样之后还放回，可以被多次抽样，false表示不放回；fraction表示抽样比例；seed为随机数种子，比如当前时间戳
2.6.3 Scala示例
val datas =Array(1, 2, 3, 7, 4, 5, 8);
sc.parallelize(datas).sample(withReplacement = false,
0.5, System.currentTimeMillis)
.foreach(println)
2.7 union
2.7.1 概述
语法（scala）：
def union(other: RDD[T]): RDD[T]
说明：
合并两个RDD，不去重，要求两个RDD中的元素类型一致
2.7.3 Scala示例
val datas1 = Array(“张三”, “李四”);
val datas2 = Array(“tom”, “gim”);
sc.parallelize(datas1).union(sc.parallelize(datas2))
.foreach(println)//第一种方式
(sc.parallelize(datas1) ++ sc.parallelize(datas2))
.foreach(println)//第二种写法
2.8 intersection
2.8.1 概述
语法（scala）：
def intersection(other: RDD[T]): RDD[T]
说明：
返回两个RDD的交集
2.8.3 Scala示例
val datas1 = Array(“张三”, “李四”, “tom”);
val datas2 = Array(“tom”, “gim”);

sc.parallelize(datas1).intersection(sc.parallelize(datas2))
        .foreach(println)

2.9 distinct
2.9.1 概述
语法（scala）：
def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]
def distinct(): RDD[T]
说明：
对原RDD进行去重操作，返回RDD中没有重复的成员
2.9.3 Scala示例
val datas1 = Array(“张三”, “李四”, “tom”, “张三”,“张三”,
“李四”, “tom”, “张三”);

sc.parallelize(datas1).distinct().foreach { x => println(x)}
2.10 groupByKey
2.10.1 概述
语法（scala）：

RDD类中

def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]

def groupBy[K](
f: T => K,
numPartitions: Int)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]

def groupBy[K](f: T => K, p: Partitioner)(implicit kt: ClassTag[K], ord: Ordering[K] = null)

RDD[(K, Iterable[T])]

PairRDDFunctions类中

def groupByKey(partitioner: Partitioner): RDD[(K, Iterable[V])]

def groupByKey(numPartitions: Int): RDD[(K, Iterable[V])]

def groupByKey(): RDD[(K, Iterable[V])]
说明：
对<key, value>结构的RDD进行类似RMDB的group by聚合操作，具有相同key的RDD成员的value会被聚合在一起，返回的RDD的结构是(key, Iterator)
2.10.3 Scala示例
sc.parallelize(1 to 9, 3)
.groupBy(x => {
if (x % 2 == 0) “偶数”
else “奇数”
})
.foreach(println)//第一种实现方式
sc.parallelize(1 to 9, 3).groupBy(niming).foreach(println)
//第二种实现方式
val datas2 = Array(“dog”, “tiger”, “lion”, “cat”, “spider”, “eagle”)
sc.parallelize(datas2)
.keyBy(_.length)
.groupByKey()
.foreach(println)
2.11 reduceByKey
2.11.1 概述
语法（scala）：
org.apache.spark.Partitioner
def reduceByKey(partitioner: Partitioner, func: (V, V) => V): RDD[(K, V)]

def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]

def reduceByKey(func: (V, V) => V): RDD[(K, V)]
说明：
对<key, value>结构的RDD进行聚合，对具有相同key的value调用func来进行reduce操作，func的类型必须是(V, V) => V
2.11.3 Scala示例
val l=List((1,3),(2,3),(3,4))
val datas2 = Array(“dog,tiger,lion,cat,spider,eagle”)
val datasRDD=sc.parallelize(datas2)
val words = datasRDD.flatMap(line => line.split(","))
val wordPairs = words.map((_,1))
val wordCounts = wordPairs.reduceByKey((a, b) => a + b)
println("wordCounts: ")
wordCounts.collect().foreach(println)
2.12 aggregateByKey
2.12.1 概述
语法（java）：
JavaPairRDD<K,U> aggregateByKey(U zeroValue)(
Partitioner partitioner,
Function2<U,V,U> seqFunc,
Function2<U,U,U> combFunc)

JavaPairRDD<K,U> aggregateByKey(U zeroValue,
int numPartitions,
Function2<U,V,U> seqFunc,
Function2<U,U,U> combFunc)

JavaPairRDD<K,U> aggregateByKey(U zeroValue,
Function2<U,V,U> seqFunc,
Function2<U,U,U> combFunc)
说明：
aggregateByKey函数对PairRDD中相同Key的值进行聚合操作，在聚合过程中同样使用了一个中立的初始值。和aggregate函数类似，aggregateByKey返回值得类型不需要和RDD中value的类型一致。因为aggregateByKey是对相同Key中的值进行聚合操作，所以aggregateByKey函数最终返回的类型还是Pair RDD，对应的结果是Key和聚合好的值；而aggregate函数直接返回非RDD的结果。
参数：
zeroValue：表示在每个分区中第一次拿到key值时,用于创建一个返回类型的函数,这个函数最终会被包装成先生成一个返回类型,然后通过调用seqOp函数,把第一个key对应的value添加到这个类型U的变量中。
seqOp：这个用于把迭代分区中key对应的值添加到zeroValue创建的U类型实例中。
combOp：这个用于合并每个分区中聚合过来的两个U类型的值。
2.12.3 Scala示例
def seq(a:Int, b:Int): Int = {
println("seq: " + a + “\t” + b)
math.max(a, b)
}
// 合并在不同partition中的值，a,b的数据类型为zeroValue的数据类型
def comb(a:Int, b:Int): Int = {
println("comb: " + a + “\t” + b)
a + b
}
val conf=new SparkConf().setAppName(“Msh”).setMaster(“local”)
val sc=new SparkContext(conf)
def main(args: Array[String]): Unit = {

	sc.parallelize(List((1, 3), (1, 2), (1, 4), (2, 3)), 2)
	.aggregateByKey(0)(seq, comb)
.foreach(println)
}2.13 sortByKey

2.13.1 概述
语法（java）：
JavaRDD sortBy(Function<T,S> f,
boolean ascending,
int numPartitions)

JavaPairRDD<K,V> sortByKey()

JavaPairRDD<K,V> sortByKey(boolean ascending)

JavaPairRDD<K,V> sortByKey(boolean ascending,
int numPartitions):RDD

JavaPairRDD<K,V> sortByKey(java.util.Comparator comp)

JavaPairRDD<K,V> sortByKey(java.util.Comparator comp,
boolean ascending)

JavaPairRDD<K,V> sortByKey(java.util.Comparator comp,
boolean ascending,
int numPartitions)
说明：
对<key, value>结构的RDD进行升序或降序排列
参数：
comp：排序时的比较运算方式。
ascending：false降序；true升序。
2.13.3 Scala示例
sc.parallelize(Array(60, 70, 80, 55, 45, 75))
.sortBy(v => v, false)
.foreach(println)

sc.parallelize(List((3, 3), (2, 2), (1, 4), (2, 3)))
    .sortByKey(true)
    .foreach(println)

2.14 join
2.14.1 概述
语法（java）：
JavaPairRDD<K,scala.Tuple2<V,W>> join(JavaPairRDD<K,W> other)

JavaPairRDD<K,scala.Tuple2<V,W>> join(
JavaPairRDD<K,W> other,
int numPartitions)

JavaPairRDD<K,scala.Tuple2<V,W>> join(
JavaPairRDD<K,W> other,
Partitioner partitioner)
说明：
对<K, V>和<K, W>进行join操作，返回(K, (V, W))外连接函数为leftOuterJoin、rightOuterJoin和fullOuterJoin
2.14.3 Scala示例
sc.parallelize(List((1, “apple”), (2, “pear”), (3, “banana”), (4, “shiliu”)))
.join(sc.parallelize(List((1, 7), (2, 3), (3, 8), (4, 3), (5, 9))))
.foreach(println)
2.15 cogroup
2.15.1 概述
语法（java）：
JavaPairRDD<K,scala.Tuple2<Iterable,Iterable>> cogroup(JavaPairRDD<K,W> other, Partitioner partitioner)

JavaPairRDD<K,scala.Tuple3<Iterable,Iterable,Iterable>> cogroup(JavaPairRDD<K,W1> other1, JavaPairRDD<K,W2> other2, Partitioner partitioner)

JavaPairRDD<K,scala.Tuple4<Iterable,Iterable,Iterable,Iterable>> cogroup(JavaPairRDD<K,W1> other1, JavaPairRDD<K,W2> other2, JavaPairRDD<K,W3> other3, Partitioner partitioner)

JavaPairRDD<K,scala.Tuple2<Iterable,Iterable>> cogroup(JavaPairRDD<K,W> other)

JavaPairRDD<K,scala.Tuple3<Iterable,Iterable,Iterable>> cogroup(JavaPairRDD<K,W1> other1, JavaPairRDD<K,W2> other2)

JavaPairRDD<K,scala.Tuple4<Iterable,Iterable,Iterable,Iterable>> cogroup(JavaPairRDD<K,W1> other1, JavaPairRDD<K,W2> other2, JavaPairRDD<K,W3> other3)

JavaPairRDD<K,scala.Tuple2<Iterable,Iterable>> cogroup(JavaPairRDD<K,W> other, int numPartitions)

JavaPairRDD<K,scala.Tuple3<Iterable,Iterable,Iterable>> cogroup(JavaPairRDD<K,W1> other1, JavaPairRDD<K,W2> other2, int numPartitions)

JavaPairRDD<K,scala.Tuple4<Iterable,Iterable,Iterable,Iterable>> cogroup(JavaPairRDD<K,W1> other1, <K,W2> other2, JavaPairRDD<K,W3> other3, int numPartitions)
说明：
cogroup:对多个RDD中的KV元素，每个RDD中相同key中的元素分别聚合成一个集合。与reduceByKey不同的是针对两个RDD中相同的key的元素进行合并。
2.15.3 Scala示例
val datas1 = List((1, “苹果”), (2, “梨”), (3, “香蕉”), (4, “石榴”))

val datas2 = List((1, 7), (2, 3), (3, 8), (5, 3))

val datas3 = List((1, "7"), (2, "3"), (3, "8"), (4, "3"), (4, "4"), (4, "5"), (4, "6"))

sc.parallelize(datas1).cogroup(sc.parallelize(datas2), sc.parallelize(datas3)).foreach(println)

// 结果
(4,(CompactBuffer(石榴),CompactBuffer(3),CompactBuffer(3, 4, 5, 6)))
(1,(CompactBuffer(苹果),CompactBuffer(7),CompactBuffer(7)))
(3,(CompactBuffer(香蕉),CompactBuffer(8),CompactBuffer(8)))
(2,(CompactBuffer(梨),CompactBuffer(3),CompactBuffer(3)))
2.16 cartesian
2.16.1 概述
语法（java）：
static JavaPairRDD<T,U> cartesian(JavaRDDLike<U,?> other)
说明：
两个RDD进行笛卡尔积合并
2.16.3 Scala示例
val names = Array (“张三”, “李四”, “王五”);
val scores = Array(60, 70, 80);
sc.parallelize(names).cartesian(sc.parallelize(scores)).foreach(println)
2.17 pipe
2.17.1 概述
语法（java）：
JavaRDD pipe(String command)

JavaRDD pipe(java.util.List command)

JavaRDD pipe(java.util.List command,
java.util.Map<String,String> env)

JavaRDD pipe(java.util.List command,
java.util.Map<String,String> env,
boolean separateWorkingDir,
int bufferSize)

static JavaRDD pipe(java.util.List command,
java.util.Map<String,String> env,
boolean separateWorkingDir,
int bufferSize,
String encoding)
说明：
执行cmd命令，创建RDD
2.17.3 Scala示例
echo.sh内容
#!/bin/bash
echo “Running shell script”
RESULT=""
while read LINE; do
RESULT=$RESULT""${LINE}
done

echo ${RESULT} > /gong/out123.txt
测试代码
val data = List(“hi”, “hello”, “how”, “are”, “you”)
sc.makeRDD(data)
.pipe("/gong/echo.sh")
.foreach(println)
结果

out123.txt

hi hello how are you

输出

Running shell script
2.18 coalesce
2.18.1 概述
语法（java）：
JavaRDD coalesce(int numPartitions)

JavaRDD coalesce(int numPartitions,
boolean shuffle)

JavaPairRDD<K,V> coalesce(int numPartitions)

JavaPairRDD<K,V> coalesce(int numPartitions,
boolean shuffle)
说明：
用于将RDD进行重分区，使用HashPartitioner。且该RDD的分区个数等于numPartitions个数。如果shuffle设置为true，则会进行shuffle。
2.18.3 Scala示例
val datas = List(“hi”, “hello”, “how”, “are”, “you”)
val datasRDD = sc.parallelize(datas, 4)
println("RDD的分区数: " + datasRDD.partitions.length)
val datasRDD2 = datasRDD.coalesce(2)
println("RDD的分区数: " + datasRDD2.partitions.length)
2.19 repartition
2.19.1 概述
语法（java）：
JavaRDD repartition(int numPartitions)

JavaPairRDD<K,V> repartition(int numPartitions)
说明：
该函数其实就是coalesce函数第二个参数为true的实现
示例略
2.20 repartitionAndSortWithinPartitions
2.20.1 概述
语法（java）：
JavaPairRDD<K,V> repartitionAndSortWithinPartitions(Partitioner partitioner)

JavaPairRDD<K,V> repartitionAndSortWithinPartitions(Partitioner partitioner,
java.util.Comparator comp)
说明：
根据给定的Partitioner重新分区，并且每个分区内根据comp实现排序。
2.20.3 Scala示例
val datas = new ArrayString
val random = new Random(1)
for (i <- 0 until 10; j <- 0 until 100) {
val index: Int = i * 100 + j
datas(index) = “product” + random.nextInt(10) + “,url” + random.nextInt(100)
}
val datasRDD = sc.parallelize(datas,10)
val pairRDD = datasRDD.map(line => (line, 1))
.reduceByKey((a, b) => a + b)

// .foreach(println)

pairRDD.repartitionAndSortWithinPartitions(new Partitioner() {
    override def numPartitions: Int = 5

    override def getPartition(key: Any): Int = {
        val str = String.valueOf(key)
        str.substring(7, str.indexOf(',')).toInt
    }
}).foreach(println)

2.20.4
combineByKey 方法是基于键进行聚合的函数
我们设聚合前Pair RDD的键值对格式为：键为K，键值格式为V；而聚合后，键格式不便，键值格式为C。
combineByKey函数的定义为：
combineByKey(createCombiner, mergeValue, mergeCombiners, numPartitions=None, partitionFunc=<function portable_hash at 0x7fc35dbc8e60>)
该函数的参数主要为前三个：
createCombiner
mergeValue
mergeCombiners
示意图如下：

一个例子
还是先看一个例子，暂时看不懂可以先看下面再回来。
val a = sc.parallelize(List(“dog”, “cat”,“gnu”,“salmon”,“rabbit”,“turkey”,“wolf”,“bear”,“bee”), 3)
val b = sc.parallelize(List(1,1,2,2,2,1,2,2,2), 3)
val c = b.zip(a)
val d = c.combineByKey(x=>List(x), (x: List[String], y:String) => y :: x, (x:List[String], y: List[String]) => x ::: y)

sc.parallelize(Array(“x”,“b”,“c”)).map((_,1)). combineByKey(x=>x,(x:Int,y:Int)=>x+y, (x:Int,y:Int)=>x+y)

下面解释这三个参数。
createCombiner
由于聚合操作会遍分区中所有的元素，因此每个元素（这里指的是键值对）的键只有两种情况：
以前没出现过
以前出现过
如果以前没出现过，则执行的是createCombiner方法；否则执行mergeValue方法，即：

.createCombiner()会在新遇到的键对应的累加器中赋予初始值。
该函数在格式上是由 V -> C 的，在上面的例子里面，是由 整数类型 -> 二元元组类型，这个二元元组第二个元素为1。
mergeValue
对于已经出现过的键（key），调用mergeValue来进行聚合操作，对该键的累加器对应的当前值（C格式）于这个新的值（V格式）进行合并。
mergeCombiners
如果有两个或者更多的分区（这里的例子里没提到）都有对应同一个键的累加器，就需要使用用户提供的mergeCombiners()方法将各个分区的结果（全是C格式）进行合并。
练习：
val data = sc.parallelize(List((1, “www”), (1, “iteblog”), (1, “com”), (2, “bbs”), (2, “iteblog”), (2, “com”), (3, “good”)))

val result = data.combineByKey(List(_), (x: List [String], y: String) => y :: x, (x: List[String], y: List[String]) => x ::: y)

result.collect

val data = sc.parallelize(List((“iteblog”, 1), (“bbs”, 1), (“iteblog”, 3)))

val result = data.combineByKey(x => x,
　　(x: Int, y:Int) => x + y, (x:Int, y: Int) => x + y)

result.collect

3. Action
   3.1 reduce
   3.1.1 概述
   语法（java）：
   static T reduce(Function2<T,T,T> f)
   def f(x:Int,y:Int)={x+y}
   rddd.reduce(+)
   rdd.reduce(f)
   说明：
   对RDD成员使用func进行reduce操作，func接受两个参数，合并之后只返回一个值。reduce操作的返回结果只有一个值。需要注意的是，func会并发执行
   3.1.2 Scala示例
   sc.parallelize(1 to 10).reduce((x, y) => x + y))

3.2 collect
3.2.1 概述
语法（java）：
static java.util.List collect()
说明：
将RDD读取至Driver程序，类型是Array，一般要求RDD不要太大。
示例略
3.3 count
3.3.1 概述
语法（java）：
static long count()
说明：
返回RDD的成员数量
3.3.2 Scala示例
sc.parallelize(1 to 10).count)

// 结果
10
3.4 first
3.4.1 概述
语法（java）：
static T first()
说明：
返回RDD的第一个成员，等价于take(1)
3.4.2 Scala示例
sc.parallelize(1 to 10).first())

// 结果
1
3.5 take
3.5.1 概述
语法（java）：
static java.util.List take(int num)
说明：
返回RDD前n个成员
3.5.2 Scala示例
sc.parallelize(1 to 10).take(2).foreach(println)

3.6 takeSample
3.6.1 概述
语法（java）：
static java.util.List takeSample(boolean withReplacement,
int num,
long seed)
说明：
和sample用法相同，只不第二个参数换成了个数。返回也不是RDD，而是collect。
3.6.2 Scala示例
sc.parallelize(1 to 10).takeSample(withReplacement = false, 3, 1).foreach(println)
3.7 takeOrdered
3.7.1 概述
语法（java）：
java.util.List takeOrdered(int num)

java.util.List takeOrdered(int num,
java.util.Comparator comp)
说明：
用于从RDD中，按照默认（升序）或指定排序规则，返回前num个元素。
3.7.2 Scala示例
sc.parallelize(Array(5,6,2,1,7,8))
.takeOrdered(3)(new OrderingInt{
override def compare(x: Int, y: Int): Int = y.compareTo(x)
}).foreach(println)
3.8 saveAsTextFile
3.8.1 概述
语法（java）：
void saveAsTextFile(String path)

void saveAsTextFile(String path,
Class<? extends org.apache.hadoop.io.compress.CompressionCodec> codec)
说明：
将RDD转换为文本内容并保存至路径path下，可能有多个文件(和partition数有关)。路径path可以是本地路径或HDFS地址，转换方法是对RDD成员调用toString函数
3.8.2 Scala示例
sc.parallelize(Array(5,6,2,1,7,8))
.saveAsTextFile("/Users/zhangws/Documents/test")

3.9 saveAsSequenceFile
3.9.1 概述
语法（java）：
def saveAsSequenceFile(path: String, codec: Option[Class[_ <: CompressionCodec]] = None): Unit
说明：
与saveAsTextFile类似，但以SequenceFile格式保存，成员类型必须实现Writeable接口或可以被隐式转换为Writable类型（比如基本Scala类型Int、String等）
示例略
3.10 saveAsObjectFile
3.10.1 概述
语法（java）：
static void saveAsObjectFile(String path)
说明：
用于将RDD中的元素序列化成对象，存储到文件中。对于HDFS，默认采用SequenceFile保存。
示例略
3.11 countByKey—输出的是一个结果，可以直接打印，也可以使用foreach打印输出
3.11.1 概述
语法（java）：
java.util.Map<K,Long> countByKey()
说明：
仅适用于(K, V)类型，对key计数，返回(K, Int)
3.11.2 Scala示例
sc.parallelize(Array((“A”, 1), (“B”, 6), (“A”, 2), (“C”, 1), (“A”, 7), (“A”, 8))).countByKey()
3.12 foreach
3.12.1 概述
语法（java）：
static void foreach(VoidFunction f)
说明：
对RDD中的每个成员执行func，没有返回值，常用于更新计数器或输出数据至外部存储系统。这里需要注意变量的作用域
3.12.2 Java示例
forEach(System.out::println);

forEach(v -> System.out.println(v));
3.12.3 Scala示例
foreach(println)
1 count
count 返回的是在一个RDD里面存储的元素的个数
def count(): Long

val c = sc.parallelize(List(“Gnu”, “Cat”, “Rat”, “Dog”), 2)
c.count

2 countApproxDistinct
计算单一值的大概的出现的次数，假设有一个分布于很多节点的很大的一个RDD，大致的计算速度会快于其他的计算方式，
Api中的参数relativeSD用于控制计算的精准度。 越小表示准确度越高
def countApproxDistinct(relativeSD: Double = 0.05): Long
val a = sc.parallelize(1 to 10000, 20)
val b = a++a++a++a++a
b.countApproxDistinct(0.1)
b.countApproxDistinct(0.05)

b.countApproxDistinct(0.01)
b.countApproxDistinct(0.001)
3 countApproxDistinctByKey [Pair]
这个作用于一个键值对类型的数据。它和之前的countApproxDistinct 是类似的。不过计算的是每个单独出现的key值的单独的value值出现的次数。RDD包含的元素的值也必须是tuple类型的元素。Api中的参数relativeSD用于控制计算的精准度。 越小表示准确度越高。
def countApproxDistinctByKey(relativeSD: Double = 0.05): RDD[(K, Long)]
def countApproxDistinctByKey(relativeSD: Double, numPartitions: Int): RDD[(K, Long)]
def countApproxDistinctByKey(relativeSD: Double, partitioner: Partitioner): RDD[(K, Long)]

val a = sc.parallelize(List(“Gnu”, “Cat”, “Rat”, “Dog”), 2)
val b = sc.parallelize(a.takeSample(true, 10000, 0), 20)
val c = sc.parallelize(1 to b.count().toInt, 20)
val d = b.zip©
d.countApproxDistinctByKey(0.1).collect
d.countApproxDistinctByKey(0.01).collect
d.countApproxDistinctByKey(0.001).collect
4 countByKey
作用于键值对类型的元素，不过计算的是每个键对应出现的value的次数。
def countByKey(): Map[K, Long]
val c = sc.parallelize(List((3, “Gnu”), (3, “Yak”), (5, “Mouse”), (3, “Dog”)), 2)
c.countByKey
5 countByValue

计算一个RDD中，每一个元素出现的次数，返回的结果为一个map型，表示的是每个值出现了几次。
def countByValue(): Map[T, Long]
1
val b = sc.parallelize(List(1,2,3,4,5,6,7,8,2,4,2,1,1,1,1,1))
b.countByValue