Spark

1.启动Spark shell 的命令  spark/bin/spark-shell  --master local[2]
  退出spark shell        :q
  启动后可以通过localhost:4040来查看spark的执行情况

2.启动spark之前需要启动hdfs，命令 hadoop/sbin/start-hdfs.sh

3.提交jar包,执行计算
/usr/local/spark/bin/spark-submit --class "WordCount"  /usr/local/spark/mycode/wordcount/target/scala-2.10/wordcount-project_2.10-1.0.jar
配置后可以通过localhost:18080来查看任务执行后的日志

4.spark-shell中停止已经启动的sparkcontext
sc.stop    (sc表示已经启动的sparkcontext名称)

5.启动Spark history server
./sbin/start-history-server.sh
地址：http://master:18080

6.persist用于设置RDD的StorageLevel。

不带参数的persist和cache函数，相当于persist(StorageLevel.MEMORY_ONLY)。

unpersist用于删除磁盘、内存中的相关序列化对象。

getStorageLevel用于查询getStorageLevel信息。

注意：RDD的StorageLevel只能设置一次。
需要引入org.apache.spark.storage.StorageLevel类

7.rdd.partitions.size  获得rdd分区的个数

8.1）Value数据类型的Transformation算子　　
　　一、输入分区与输出分区一对一型
　　　　1、map算子
　　　　2、flatMap算子
　　　　3、mapPartitions算子
　　　　4、glom算子
　　二、输入分区与输出分区多对一型　
　　　　5、union算子
　　　　6、cartesian算子
　　三、输入分区与输出分区多对多型
　　　　7、grouBy算子
　　四、输出分区为输入分区子集型
　　　　8、filter算子
　　　　9、distinct算子
　　　　10、subtract算子
　　　　11、sample算子
     　 12、takeSample算子
 　　五、Cache型
　　　　13、cache算子　　
　　　　14、persist算子
2）Key-Value数据类型的Transfromation算子
　　一、输入分区与输出分区一对一
　　　　15、mapValues算子
　　二、对单个RDD或两个RDD聚集
　　　单个RDD聚集
　　　　16、combineByKey算子
　　　　17、reduceByKey算子
　　　　18、partitionBy算子
 　　两个RDD聚集
　　　　19、Cogroup算子
　　三、连接
　　　　20、join算子
　　　　21、leftOutJoin和 rightOutJoin算子
 3）Action算子
　　一、无输出
　　　　22、foreach算子
　　二、HDFS
　　　　23、saveAsTextFile算子
　　　　24、saveAsObjectFile算子
　　三、Scala集合和数据类型
　　　　25、collect算子
　　　　26、collectAsMap算子
 　　　 27、reduceByKeyLocally算子
 　　　 28、lookup算子
　　　　29、count算子
　　　　30、top算子
　　　　31、reduce算子
　　　　32、fold算子
　　　　33、aggregate算子

9.生成RDD的方法
1)驱动程序对程序中的集合进行并行化 sc.parallelize()
2)读取外部数据集 sc.txtFile("file:///usr/lpq/spark/wordcount.txt")

10.查看RDD内容的方法
（1）写出到文件系统，即调用所使用的RDD的类中类似saveasTextFile()的方法，例如  对于JavaPairRDD的对象x可以用      x.saveasTextFile("输出文件路径"):

（2）单机模式中使用rdd.foreach(println)或者rdd.map(println)。但是，当采用集群模式执行时为了能够把所有worker节点上的打印输出信息也显示到Driver Program中，可以使用collect()方法，比如，rdd.collect().foreach(println)，但是，由于collect()方法会把各个worker节点上的所有RDD元素都抓取到Driver Program中，因此，这可能会导致内存溢出。因此，当你只需要打印RDD的部分元素时，可以采用语句rdd.take(100).foreach(println)。

10.
1)mapPartitions

def mapPartitions[U](f: (Iterator[T]) => Iterator[U], preservesPartitioning: Boolean = false)(implicit arg0: ClassTag[U]): RDD[U]

该函数和map函数类似，只不过映射函数的参数由RDD中的每一个元素变成了RDD中每一个分区的迭代器。如果在映射的过程中需要频繁创建额外的对象，使用mapPartitions要比map高效的过。

比如，将RDD中的所有数据通过JDBC连接写入数据库，如果使用map函数，可能要为每一个元素都创建一个connection，这样开销很大，如果使用mapPartitions，那么只需要针对每一个分区建立一个connection。

参数preservesPartitioning表示是否保留父RDD的partitioner分区信息。

 

    var rdd1 = sc.makeRDD(1 to 5,2)
    //rdd1有两个分区
    scala> var rdd3 = rdd1.mapPartitions{ x => {
         | var result = List[Int]()
         |     var i = 0
         |     while(x.hasNext){
         |       i += x.next()
         |     }
         |     result.::(i).iterator
         | }}
    rdd3: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[84] at mapPartitions at :23
     
    //rdd3将rdd1中每个分区中的数值累加
    scala> rdd3.collect
    res65: Array[Int] = Array(3, 12)
    scala> rdd3.partitions.size
    res66: Int = 2
     

2)mapPartitionsWithIndex

def mapPartitionsWithIndex[U](f: (Int, Iterator[T]) => Iterator[U], preservesPartitioning: Boolean = false)(implicit arg0: ClassTag[U]): RDD[U]

函数作用同mapPartitions，不过提供了两个参数，第一个参数为分区的索引。

    var rdd1 = sc.makeRDD(1 to 5,2)
    //rdd1有两个分区
    var rdd2 = rdd1.mapPartitionsWithIndex{
            (x,iter) => {
              var result = List[String]()
                var i = 0
                while(iter.hasNext){
                  i += iter.next()
                }
                result.::(x + "|" + i).iterator
               
            }
          }
    //rdd2将rdd1中每个分区的数字累加，并在每个分区的累加结果前面加了分区索引
    scala> rdd2.collect
    res13: Array[String] = Array(0|3, 1|12)