spark官网 repartition

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])] 
   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 sortByKey2.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):RDDJavaPairRDD<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={LINE}
 doneecho ${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(): Longval 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