Flink中Transformation算子（一）

package batch.BatchAPI

import org.apache.flink.api.common.operators.Order
import org.apache.flink.api.scala.{DataSet, ExecutionEnvironment}
import scala.collection.mutable.ListBuffer

/**
  * @author Jacky
  *         Map：输入一个元素，然后返回一个元素，中间可以做一些清洗转换等操作
  *         FlatMap：输入一个元素，可以返回零个，一个或者多个元素
  *         MapPartition：类似map，一次处理一个分区的数据【如果在进行map处理的时候需要获取第三方资源链接，建议使用MapPartition】
  *         Filter：过滤函数，对传入的数据进行判断，符合条件的数据会被留下
  *         Reduce：对数据进行聚合操作，结合当前元素和上一次reduce返回的值进行聚合操作，然后返回一个新的值
  *         Aggregate：sum、max、min等
  *         Distinct：返回一个数据集中去重之后的元素，data.distinct()
  *         Join：内连接
  *         OuterJoin：外链接
  *         Cross：获取两个数据集的笛卡尔积
  *         Union：返回两个数据集的总和，数据类型需要一致
  *         First-n：获取集合中的前N个元素
  *         Sort Partition：在本地对数据集的所有分区进行排序，通过sortPartition()的链接调用来完成对多个字段的排序
  */
object TransformationDemoScala {
  def main(args: Array[String]): Unit = {
    val env = ExecutionEnvironment.getExecutionEnvironment
    //隐式转换
    import org.apache.flink.api.scala._
    val list = ListBuffer[String]()
    list.append("hello you")
    list.append("hadoop and spark")
    list.append("spark and flink")
    list.append("hello flink")
    val datas: DataSet[String] = env.fromCollection(list)
    println("===========mapPartition算子=================")
    datas.mapPartition(it => {
      val list = ListBuffer[String]()
      while (it.hasNext) {
        val data = it.next()
        val words = data.split(" ")
        for (word <- words) {
          list.append(word)
        }
      }
      list
    }).print()
    println("===========distinct算子=================")
    datas.flatMap(_.split(" ")).distinct().print()
    println("==============下面是join相关算子==========================")
    val data1: ListBuffer[(Int, String)] = ListBuffer[Tuple2[Int, String]]()
    data1.append((1, "张三"))
    data1.append((2, "李四"))
    data1.append((3, "jakcy"))
    val text1 = env.fromCollection(data1)

    val data2 = ListBuffer[Tuple2[Int, String]]()
    data2.append((2, "北京"))
    data2.append((3, "上海"))
    data2.append((4, "伦敦"))
    val text2 = env.fromCollection(data2)
    println("===========join算子=================")
    text1.join(text2).where(0).equalTo(0).apply((first, second) => {
      (first._1, first._2, second._2)
    }).print()
    println("===========leftOuterJoin算子=================")
    text1.leftOuterJoin(text2).where(0).equalTo(0).apply((first, second) => {
      if (second == null) {
        (first._1, first._2, "null")
      } else {
        (first._1, first._2, second._2)
      }
    }).print()
    println("===========rightOuterJoin算子=================")
    text1.rightOuterJoin(text2).where(0).equalTo(0).apply((first, second) => {
      if (first == null) {
        (second._1, "null", second._2)
      } else {
        (second._1, first._2, second._2)
      }
    }).print()
    println("===========fullOuterJoin算子=================")
    text1.fullOuterJoin(text2).where(0).equalTo(0).apply((first, second) => {
      if (first == null) {
        (second._1, "null", second._2)
      } else if (second == null) {
        (first._1, first._2, "null")
      } else {
        (first._1, first._2, second._2)
      }
    }).print()

    println("================Cross：获取两个数据集的笛卡尔积=================")
    text1.cross(text2).print()
    println("================Union：返回两个数据集的总和，数据类型需要一致=================")
    val unionDatas = text1.union(text2)
    unionDatas.print()

    println("==============First-n：获取集合中的前N个元素===================")
    //将datas中的数据按第1个字段分组，然后取出每组中的前2个元素，相当于“分组取TOP N”
    unionDatas.groupBy(0).first(2).print()
    println("===========================================")
    //将datas中的数据按第1个字段分组，并在组中按第2个字段降序排序，然后取出每组中的前2个元素，相当于“分组排序取TOP N”
    unionDatas.groupBy(0).sortGroup(1, Order.DESCENDING).first(2).print()
    println("===========================================")
    //将datas中的数据进行全局降序排序，并取出前3个元素
    unionDatas.sortPartition(0, Order.ASCENDING).first(3).print()
  }
}