spark-core 常用算子

1、Map算子

单列value算子

def map[U: ClassTag](f: T => U): RDD[U]//函数签名，进行数据转换，一对一进行(elem,type)

例 从apache.log中读取数据，获取指定的url

  val datardd = sc.textFile("datas/apache.log",4)
    val unit:RDD[String] = datardd.map(Line => {
       val datas= Line.split(" ")
          datas(6)
    })

2、mappartitions
单列value 算子

def mapPartitions[U: ClassTag](
 f: Iterator[T] => Iterator[U],
 preservesPartitioning: Boolean = false): RDD[U]
 /**
 读取分区内的一批数据，进行处理，可以进行任意数据处理，也可以进行数据过滤，
 传入的是迭代器，返回类型也为迭代器
  **/

例：获取多个分区的最大值

val datardd = sc.makeRDD(List(1,2,3,4,5,6),3)
    val unit = datardd.mapPartitions(
      iter => {
        List(iter.max).iterator
      }
    )

map与mappartitions的区别

 数据处理角度
Map 算子是分区内一个数据一个数据的执行，类似于串行操作。而 mapPartitions 算子
是以分区为单位进行批处理操作。
 功能的角度
Map 算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。
MapPartitions 算子需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变，
所以可以增加或减少数据
 性能的角度
Map 算子因为类似于串行操作，所以性能比较低，而是 mapPartitions 算子类似于批处
理，所以性能较高。但是 mapPartitions 算子会长时间占用内存，那么这样会导致内存可能
不够用，出现内存溢出的错误。所以在内存有限的情况下，不推荐使用。使用 map 操作

3、flatmap

def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]
//将数据进行扁平化处理，后进行map映射

例：将 List(List(1,2),3,List(4,5))进行扁平化操作

 var datardd= sc.makeRDD(List(List(1,2,3),4,List(5,6,7)))
      datardd.flatMap(
          line =>{
          line match {
            case line: List[_] => {
              line.map(word => word)
            }
            case line: Int => {
              List(line)
            }
          }
          }
      ).collect().foreach(println)

4、 glom

def glom(): RDD[Array[T]
//将同一个分区内的数据直接转换为相同类型的的内存数据进行处理，分区不变

例 求不同分区内的最大值之和

  var datardd= sc.makeRDD(List(1,2,3,4,5,6),2)
     val unit = datardd.glom()
    println(unit.map(
      arr =>
        arr.max
    ).collect().sum)

6 group by

def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]
//将数据根据指定的规则进行分组, 分区默认不变，但是数据会被打乱重新组合，我们将这样
的操作称之为 shuffle。极限情况下，数据可能被分在同一个分区中
一个组的数据在一个分区中，但是并不是说一个分区中只有一个组

例： 将 List(“Hello”, “hive”, “hbase”, “Hadoop”)根据单词首写字母进行分组

 var datardd:RDD[String] = sc.makeRDD(List(
      "hello word","Sello scala","Hello spark"
    ),3)
    datardd.groupBy(
       line =>{
         line.charAt(0)
       }
    ).collect().foreach(println)
  }

7、 filter

def filter(f: T => Boolean): RDD[T]
//将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。
//当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，生产环境下，可能会出
//现数据倾斜。

例：从服务器日志数据 apache.log 中获取 2015 年 5 月 17 日的请求路径

    val rdd = sc.textFile("datas/apache.log")
    val unit = rdd.map(
      line => {
        var data = line.substring(17)//截取url前的多余字符
        data
      }
    )
   unit.filter(
     line =>{
        var str=line.substring(0,10)
        str=="17/05/2015"//判断条件，返回true or false
     }
   ).collect().foreach(println)
  }