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()
}
}