Spark-Scala常用函数

一、读取

    1、textFile()  读取外部数据源

    2、 map() 遍历每条数据处理

    3、mapvalues(_+10) 传入一个函数，类似于map方法，不过这里只是对元组中的value进行计算

    4、keys values
    val rdd1 = sc.parallelize(List("dog", "tiger", "lion", "cat", "panther", "eagle"), 2)
    val rdd2 = rdd1.map(x => (x.length, x))
    rdd2.keys.collect
    rdd2.values.collect

二、切分

    1、slice(0,10)    //取前十条数据

    2、collect()：一般在filter或者足够小的结果的时候，再用collect封装返回一个数组

    3、count():返回的是dataset中的element的个数

    4、first():返回的是dataset中的第一个元素      类似于take（1）

    5、take(n):返回前n个elements，这个士driver program返回的

    6、takeSample(withReplacement，num，seed)：抽样返回一个dataset中的num个元素，随机种子seed

   7、 takeOrdered(n, [ordering])返回一个由数据集的前n个元素组成的有序数组，使用自然序或自定义的比较器。

三、聚合

    1、 reduceByKey(_+_) 传入一个函数，将key相同的一类进行聚合计算 如相加

    2、a.foldLeft(0)(_+_)    //列表求和，其中0为初始值，前面的_代表sum，后面的_代表下一个元素，此函数等同于下面的代码
    sum = 0
    for i in a:
sum += i
    return sum

四、分组

    1、groupBy() 对指定字段进行分组

五、过滤

   1、filter() 传入一个函数， 用户过滤处理数据 

    2、filterByRange
    val rdd1 = sc.parallelize(List(("e", 5), ("c", 3), ("d", 4), ("c", 2), ("a", 1)))
    val rdd2 = rdd1.filterByRange("b", "d")
    rdd2.collect

六、排序

    1、sortBy() 传入对哪个字段进行排序 对数据进行排序（为list函数）

        sortBy(_._2).reverse == sortWith(_._2>_._2)//_._2表示按照第二个进行排序

    1.1、sortByKey([ascending],[numTasks]):按照key来进行排序，是升序还是降序，ascending是boolean类型

    2、reverse 将排序好的数据进行反转

    3、it.toList 将Iterator转换为list 然后就可以使用list的sortBy()函数进行排序

    4、.iterator  it.toList.sortBy(_._2._2).reverse.take(2).iterator  将数据转换为iterator

七、转换

    1、map().flatten==flatMap()//将数据内部嵌套的数据格式打平，例如：list（Array（），Array（））格式数据（（1，2，3），（4，5，6））打平为list（）格式数据（1，2，3，4，5，6）

    2、

八、分区
    1、partitionBy() 传入一个自定义的分区类，可进行数据的分区，
    2、mapPartitions() 对每个分区中的每条数据进行处理 类似于map，不过map是针对整个数据的，而mapPartitions()是针对分区
    假设一个rdd有10个元素，分成3个分区。如果使用map方法，map中的输入函数会被调用10次；而使用mapPartitions方法的话，其输入函数 会只会被调用3次，每个分区调用1次。返回的数据需要转换为iterator
    3、aggregate()()第一个参数需要传入一个初始值,第二个参数需要传入两个函数[每个函数都是2个参数(第一个参数:先对每个分区进行合并, 第二个:对个个分区合并后的结果再进行合并), 输出一个参数]
val rdd1 = sc.parallelize(List(1,2,3,4,5,6,7,8,9), 2)
rdd1.aggregate(0)(_+_, _+_) 求和
rdd1.aggregate(0)(math.max(_, _), _ + _) 先取出每个分区的最大值，再求和
val rdd2 = sc.parallelize(List("a","b","c","d","e","f"),2)
rdd2.aggregate("=")(_ + _, _ + _)
结果：==def=abc
    4、foreachPartition()对分区内的每个元素进行操作，
val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 3)
rdd1.foreachPartition(x => println(x.reduce(_ + _)))
可以用如下代替
val rdd1 = sc.parallelize(List(2, 1, 3, 5, 4, 6, 7, 8, 9), 3)
    val rdd2 = rdd1.mapPartitions(x => {
      var result = List[Int]()
      result.::(x.toList.sum).iterator
    })