快速入門Flink(5)——Flink中的17種TransFormAction算子（面試必問，建議收藏）-有解無憂

在這里插入圖片描述

上篇博客給大家講解了Flink的入門及dataSource 點擊，本篇博客給講解下Flink的17種常用的算子，本篇博客比較長，耐心看完（注意：面試經常被問到，建議收藏，如要對你有幫助的話麻煩，點贊關注評論），Flink專欄

1、Map

需求： 將 DataSet 中的每一個元素轉換為另外一個元素
示例: 使用 map 操作，將以下資料 “1,張三”, “2,李四”, “3,王五”, “4,趙六” 轉換為一個 scala 的樣例類，
實作步驟：

獲取 ExecutionEnvironment 運行環境，
使用 FromCollection 構建資料源，
創建一個 User 樣例類
使用 Map 將資料轉化為樣例類
列印輸出

參考代碼

import org.apache.flink.api.scala._

/**
 * @author 需求： 使用Map將資料轉換成樣例類
 * @date 2020/9/8 23:26
 * @version 1.0
 */

object BatchMap {
  case class User(name:String,age:String)
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.使用fromElements
    val data = env.fromElements("張三,19", "李四,30", "劉恒,299")
    //3.使用map將資料封裝成樣例類
    val userDataSet = data.map(s => {
      User(s.split(",")(0), s.split(",")(1))
    })
    //4.將資料輸出
    userDataSet.print()
  }
}

2、FlatMap

需求： 將 DataSet 中的每一個元素轉換為 0…n 個元素
實體： 分別將以下資料，轉換成國家、省份、城市三個維度的資料，
將以下資料

張三,中國,江西省,南昌市
李四,中國,河北省,石家莊市
Tom,America,NewYork,Manhattan

轉換為

張三,中國
張三,中國江西省
張三,中國江西省南昌市

解題思路
以上資料為一條轉換為三條，顯然，應當使用 flatMap 來實作分別在 flatMap 函式中構建三個資料，并放入到一個串列中
顯示結果

姓名, 國家
姓名, 國家省份
姓名, 國家省份城市

實作步驟：

構建批處理運行環境
構建本地集合資料源
使用 flatMap 將一條資料轉換為三條資料
a. 使用逗號分隔欄位
b. 分別構建國家、國家省份、國家省份城市三個元組
列印輸出

代碼實作:

import org.apache.flink.api.scala._

/**
 * @author 需求：
 *        將"張三,中國,江西省,南昌市",
 *         "李四,中國,河北省,石家莊市",
 *         "Tom,America,NewYork,Manhattan"
 *        轉換為：
 *        張三,中國
 *        張三,中國江西省
 *        張三,中國江西省南昌市
 * @date 2020/9/9 0:11
 * @version 1.0
 */
object BachFlatMap {
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.使用fromCollection構建資料集
    val dataSource = env.fromCollection(List("張三,中國,江西省,南昌市", "李四,中國,河北省,石家莊市", "Tom,America,NewYork,Manhattan"))
    val flatMap: DataSet[((String, String), (String, String), (String, String))] = dataSource.flatMap(line => {
      val arr = line.split(",")
      List(
         ((arr(0), arr(1)),
          (arr(0), arr(1) + arr(2)),
          (arr(0), arr(1) + arr(2) + arr(3))))
    })
   flatMap.print()
  }
}

3、MapPartition

需求： 將一個磁區中的元素轉換為另一個元素
示例： 使用 mapPartition 操作，將以下資料 “1,張三”, “2,李四”, “3,王五”, “4,趙六” 轉換為一個 scala 的樣例類，
實作步驟：

獲取 ExecutionEnvironment 運行環境
使用 fromCollection 構建資料源
創建一個 User 樣例類
使用 mapPartition 操作執行轉換
列印測驗

代碼實作：

import org.apache.flink.api.scala._
/**
 * @author 需求:將一天磁區中的資料轉換為一個樣例類
 *          "1,張三", "2,李四", "3,王五", "4,趙六"
 * @date 2020/9/9 21:57
 * @version 1.0
 */
object BachMapPartition {
  case class User(id:String,name:String)
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.使用FromElements構建資料集
    val dataSource = env.fromElements("1,張三", "2,李四", "3,王五", "4,趙六")
    //3.資料處理
    val mapPartitionDS: DataSet[User] = dataSource.mapPartition(textPartition => {
      textPartition.map( x => {
        val arrs = x.split(",")
        User(arrs(0), arrs(1))
      })
    })
    //4.結果輸出
    mapPartitionDS.print()
  }
}

4、Filter

需求： 過濾出來一些符合條件的元素
Filter作用： Filter 函式在實際生產中特別實用，資料處理階段可以過濾掉大部分不符合業務的內容，可以極大減輕整體 flink 的運算壓力
實體： 使用filter過濾掉大于10的數字
實作步驟：

獲取 ExecutionEnvironment 運行環境
使用 fromCollection 構建資料源
使用 filter 操作執行過濾
列印測驗

參考代碼

import org.apache.flink.api.scala._
/**
 * @author 需求：使用filter過濾掉大于10的數字
 *         過濾出來 一些符合條件的元素 Filter 函式在實際生產中特別實用，資料處理階段可以過濾掉大部分不符合業務的內容，
 *         可以極 大減輕整體 flink 的運算壓力
 * @date 2020/9/9 22:35
 * @version 1.0
 */
object BachFilter {
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.構建1-20的資料集
    val dataSource = env.generateSequence(1, 20)
    //3.處理資料
    val filter = dataSource.filter(_ < 10)
    //4.結果輸出
    filter.print()
  }
}

5、Reduce

需求： 可以對一個 dataset 或者一個 group 來進行聚合計算，最終聚合成一個元素
實體： 請將以下元組資料，使用 reduce 操作聚合成一個最終結果 (“java” , 1) , (“java”, 1) ,(“java” , 1) 將上傳元素資料轉換為 (“java”,3)
實作步驟：

獲取 ExecutionEnvironment 運行環境
使用 fromCollection 構建資料源
使用 redice 執行聚合操作
列印測驗

參考代碼:

import org.apache.flink.api.scala._

/**
 * @author 需求：請將以下元組資料，使用 reduce 操作聚合成一個最終結果
 *         ("java" , 1) , ("java", 1) ,("java" , 1)
 * @date 2020/9/9 22:39
 * @version 1.0
 */
object BachReduce {
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.使用fromElements 構建資料集
    val dataSource = env.fromElements(("java", 1), ("java", 1), ("java", 2))
    //3.資料處理（根據key進行分組）
    val values = dataSource.groupBy(_._1)
    //4.使用reduce進行合并
    val reduce = values.reduce((v1, v2) => (v1._1, v2._2 + v1._2))
    //4.結果輸出
    reduce.print()
  }
}

6、ReduceGroup

可以對一個 dataset 或者一個 group 來進行聚合計算，最終聚合成一個元素 reduce 和 reduceGroup 的區別
在這里插入圖片描述
首先 groupBy 函式會將一個個的單詞進行分組，分組后的資料被 reduce 一個個的拉取過來，這種方式如果資料量大的情況下，拉取的資料會非常多，增加了網路 IO，
reduceGroup 是 reduce 的一種優化方案；它會先分組 reduce，然后在做整體的 reduce；這樣做的好處就是可以減少網路 IO，
示例： 請將以下元組資料，下按照單詞使用 groupBy 進行分組，再使用 reduceGroup 操作進行單詞計數(“java” , 1) , (“java”, 1) ,(“scala” , 1)
實作步驟：

獲取 ExecutionEnvironment 運行環境
使用 fromCollection 構建資料源
使用 groupBy 按照單詞進行分組
使用 reduceGroup 對每個分組進行統計
列印測驗

參考代碼

import org.apache.flink.api.scala._

/**
 * @author 請將以下元組資料，下按照單詞使用 groupBy 進行分組，再使用 reduceGroup 操作進行單 詞計數("java" , 1) , ("java", 1) ,("scala" , 1)
 * @date 2020/9/11 22:15
 * @version 1.0
 */
object  BachReduceGroup {
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.構建資料集
    val source = env.fromElements(("java", 1), ("Flin", 1), ("大資料", 1), ("java", 2))
    //3.使用reduceGroup進行分組求和
    val result = source.groupBy(0).reduceGroup(group => (group.reduce((a, b) => (a._1, a._2 + b._2))))
    //4.輸出
    result.print()
  }
}

7、Aggregate（重點）

介紹： 按照內置的方式來進行聚合，例如：SUM/MIN/MAX…
示例： 請將以下元組資料，使用 aggregate 操作進行單詞統計 (“java”, 1), (“大資料”, 2), (“大資料”, 10)
實作步驟：

獲取 ExecutionEnvironment 運行環境
使用 fromCollection 構建資料源
使用 groupBy 按照單詞進行分組
使用 aggregate 對每個分組進行 SUM 統計
列印測驗

參考代碼

import org.apache.flink.api.scala._
/**
 * @author 請將以下元組資料，使用 aggregate 操作進行單詞統計 ("java", 1), ("大資料", 2), ("大資料", 10)
 * @date 2020/9/11 22:30
 * @version 1.0
 */
object BachAggregate {
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.使用fromElements構建資料集
    val sourceData = env.fromElements(("java", 1), ("大資料", 2), ("大資料", 10))
    //3.使用groupBy進行分組然后使用aggregate求出最大值
    val result = sourceData.groupBy(0).aggregate(Aggregations.MAX, 1)
    //4.結果輸出
    result.print()
  }
}

8、minBy 和 maxBy

介紹： 獲取指定欄位的最大值、最小值
示例： 請將以下元組資料，使用 aggregate 操作進行單詞統計 (1, “yuwen”, 89.0) , (2, “shuxue”, 92.2),(3, “yingyu”, 89.99)，(4, “wuli”, 98.9)， (1, “yuwen”, 88.88)，(1, “wuli”, 93.00)，(1, “yuwen”, 94.3)
實作步驟：

獲取 ExecutionEnvironment 運行環境
使用 fromCollection 構建資料源
使用 groupBy 按照單詞進行分組
使用 maxBy、minBy對每個分組進行操作
列印測驗

參考代碼：

import org.apache.flink.api.scala._
import scala.collection.mutable
import scala.util.Random

/**
 * @author
 * @date 2020/9/11 22:40
 * @version 1.0
 */
object BachMinByAndMaxBy {
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.構建資料集
    val data = new mutable.MutableList[(Int, String, Double)]
    data += ((1, "liuheng", 89.0))
    data += ((2, "shuxue", 92.2))
    data += ((3, "yingyu", 89.99))
    data += ((4, "wuli", 98.9))
    data += ((1, "yuwen", 88.88))
    data += ((1, "wuli", 93.00))
    data += ((1, "yuwen", 94.3))
    val sourceData = env.fromCollection(Random.shuffle(data))
    //3.使用MinBy求出最小值與MaxBy求出最大值
    val min = sourceData.groupBy(1).minBy(2)
    val max = sourceData.groupBy(1).maxBy(2)
    //4.輸出最小值
    min.print()
    println("-----------------------------")
    //5.輸出最大值
    max.print()
  }
}

9、Distinct

介紹： 去除重復的資料
示例： 請將以下元組資料，使用 distinct 操作去除重復的單詞 (“java” , 1) , (“java”, 1) ,(“scala” , 1) 去重得到 (“java”, 1), (“scala”, 1)
實作步驟：

獲取 ExecutionEnvironment 運行環境
使用 fromCollection 構建資料源
使用 distinct 指定按照哪個欄位來進行去重
列印測驗

參考代碼：

import org.apache.flink.api.scala._
/**
 * @author 需求：使用distinct求("java", 1), ("java", 2), ("scala", 1) 去掉重復的資料
 * @date 2020/9/12 22:56
 * @version 1.0
 */
object BachDistinct {
  def main(args: Array[String]): Unit = {
    //1.構建運行環境(背景關系物件)
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.使用fromElements
    val dataSource = env.fromElements(("java", 1), ("java", 2), ("scala", 1))
    //3.使用distinct去掉重復的
    val distinct = dataSource.distinct(0)
    //4.結果輸出
    distinct.print()
  }
}

10、Join

介紹： 使用 join 可以將兩個 DataSet 連接起來
示例： 有兩個 csv 檔案，有一個為 score.csv ，一個為 subject.csv ，分別保存了成績資料以及學科資料
sorce.csv

1,語數
2,英物
3,化生
4,文學
5,語理
6,學物

subject.csv

1,張三,1,98
2,張三,2,77.5
3,張三,3,89
4,張三,4,65
5,張三,5,78
6,張三,6,70
9,李四,3,65
10,李四,4,78
11,李四,5,70
12,李四,6,78
13,王五,1,70
14,王五,2,78

實作步驟：

分別將資料中的兩個檔案復制到專案中的 data/ 中
構建批處理環境
創建兩個樣例類
a. 學科 Subject（學科 ID、學科名字）
b. 成績 Score（唯一 ID、學生姓名、學科 ID、分數——Double 型別）
分別使用 readCsvFile 加載 csv 資料源，并制定泛型
使用 join 連接兩個 DataSet，并使用 where 、 equalTo 方法設定關聯條件
列印關聯后的資料源

參開代碼：

import org.apache.flink.api.scala._

/**
 * @author 需求：使用join的方式將sorce.csv檔案與subject.csv檔案進行關聯
 * @date 2020/9/12 23:38
 * @version 1.0
 */
object BachJoin {
  //構建樣例類
  case class sorce(id:String,subject:String)
  case class subject(id:String,name:String,sid:String,source:String)
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.構建資料集(使用檔案方式)
    val sorce = env.readCsvFile[sorce]("./data/score.csv")
    val subject = env.readCsvFile[subject]("./data/subject.csv")
    //3.使用join將兩個檔案中的資料進行關聯
    val joinData = sorce.join(subject).where(_.id).equalTo(_.sid)
    //4.結果輸出
    joinData.print()
  }
}

11、LeftOuterJoin

介紹： 左外連接,左邊的 Dataset 中的每一個元素，去連接右邊的元素
示例： 請將以下元組資料

(用戶 id,用戶姓名)
(1, “zhangsan”) ,
(2, “lisi”) ,
(3 , “wangwu”) ,
(4 , “zhaoliu”)

元組資料

(用戶 id,所在城市)
(1, “beijing”),
(2, “shanghai”),
(4, “guangzhou”)

回傳如下資料：

(3,wangwu,null)
(1,zhangsan,beijing)
(2,lisi,shanghai)
(4,zhaoliu,guangzhou)

參考代碼


import scala.collection.mutable.ListBuffer

/**
 * @author 需求：使用左連接 請將以下元組資料(用戶 id,用戶姓名)
 *         (1, "zhangsan") ,
 *         (2, "lisi") ,
 *         (3 , "wangwu") ,
 *         (4 , "zhaoliu")
 *         元組資料
 *         (用戶 id,所在城市)
 *         (1, "beijing"),
 *         (2, "shanghai"),
 *         (4, "guangzhou")
 *         回傳如下資料：
 *         (3,wangwu,null)
 *         (1,zhangsan,beijing)
 *         (2,lisi,shanghai)
 *         (4,zhaoliu,guangzhou)
 * @date 2020/9/15 23:30
 * @version 1.0
 */
object BachLeftOuterJoin {
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.創建要測驗的資料集
    val data1 = ListBuffer[Tuple2[Int, String]]()
    data1.append((1, "zhangsan"))
    data1.append((2, "lisi"))
    data1.append((3, "wangwu"))
    data1.append((4, "zhaoliu"))
    val data2 = ListBuffer[Tuple2[Int, String]]()
    data2.append((1, "beijing"))
    data2.append((2, "shanghai"))
    data2.append((4, "guangzhou"))
    //2.2 使用fromCollection構建資料集
    val test1 = env.fromCollection(data1)
    val test2 = env.fromCollection(data2)
    //3.使用leftOuterJoin 進行關聯
    val result = test1.leftOuterJoin(test2).where(0).equalTo(0).apply((first, second)=>{
      if (second==null){
        (first._1,first._2,"null")
      }else{
        (first._1,first._2,second._2)
      }
    })
    //4.結果輸出
    result.print()
  }
}

12、RightOuterJoin

實體： 右外連接,左邊的 Dataset 中的每一個元素，去連接左邊的元素
示例： 請將以下元組資料

(用戶 id,用戶姓名)
(1, “zhangsan”) ,
(2, “lisi”) ,
(3 , “wangwu”) ,
(4 , “zhaoliu”)

元組資料

(用戶 id,所在城市)
(1, “beijing”),
(2, “shanghai”),
(4, “guangzhou”)

回傳如下資料：

(1,zhangsan,beijing)
(2,lisi,shanghai)
(4,zhaoliu,guangzhou)

參考代碼


import org.apache.flink.api.scala._

import scala.collection.mutable.ListBuffer

/**
 * @author 需求：使用左連接 請將以下元組資料(用戶 id,用戶姓名)
 *         (1, "zhangsan") ,
 *         (2, "lisi") ,
 *         (3 , "wangwu") ,
 *         (4 , "zhaoliu")
 *         元組資料
 *         (用戶 id,所在城市)
 *         (1, "beijing"),
 *         (2, "shanghai"),
 *         (4, "guangzhou")
 *         回傳如下資料：
 *         (1,zhangsan,beijing)
 *         (4,zhaoliu,guangzhou)
 *         (2,lisi,shanghai)
 * @date 2020/9/15 23:30
 * @version 1.0
 */
object BachRightOuterJoin {
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.創建要測驗的資料集
    val data1 = ListBuffer[Tuple2[Int, String]]()
    data1.append((1, "zhangsan"))
    data1.append((2, "lisi"))
    data1.append((3, "wangwu"))
    data1.append((4, "zhaoliu"))
    val data2 = ListBuffer[Tuple2[Int, String]]()
    data2.append((1, "beijing"))
    data2.append((2, "shanghai"))
    data2.append((4, "guangzhou"))
    //2.2 使用fromCollection構建資料集
    val test1 = env.fromCollection(data1)
    val test2 = env.fromCollection(data2)
    //3.使用rightOuterJoin 進行關聯
    val result = test1.rightOuterJoin(test2).where(0).equalTo(0).apply((first, second)=>{
      if (second==null){
        (first._1,first._2,"null")
      }else{
        (first._1,first._2,second._2)
      }
    })
    //4.結果輸出
    result.print()
  }
}

13、fullOuterJoin

介紹： 全外連接,左右兩邊的元素，全部連接
示例： 請將以下元組資料

(用戶 id,用戶姓名)
(1, “zhangsan”) ,
(2, “lisi”) ,
(3 , “wangwu”) ,
(4 , “zhaoliu”)

元組資料

(用戶 id,所在城市)
(1, “beijing”),
(2, “shanghai”),
(4, “guangzhou”)

回傳如下資料：

(3,wangwu,null)
(1,zhangsan,beijing)
(2,lisi,shanghai)
(4,zhaoliu,guangzhou)

擴展：

OPTIMIZER_CHOOSES：將選擇權交予Flink優化器，相當于沒有給提示；
BROADCAST_HASH_FIRST：廣播第一個輸入端，同時基于它構建一個哈希表，而第二個輸入端作為探索端，選擇這種策略的場景第一個輸入端規模很小；
BROADCAST_HASH_SECOND：廣播第二個輸入端并基于它構建哈希表，第一個輸入端作為探索端，選擇這種策略的場景是第二個輸入端的規模很小；
REPARTITION_HASH_FIRST：該策略會導致兩個輸入端都會被重磁區，但會基于第一個輸入端構建哈希表，該策略適用于第一個輸入端資料量小于第二個輸入端的資料量，但這兩個輸入端的規模仍然很大，優化器也是當沒有辦法估算大小，沒有已存在的磁區以及排序順序可被使用時系統默認采用的策略；
REPARTITION_HASH_SECOND：該策略會導致兩個輸入端都會被重磁區，但會基于第二個輸入端構建哈希表，該策略適用于兩個輸入端的規模都很大，但第二個輸入端的資料量小于第一個輸入端的情況；
REPARTITION_SORT_MERGE：輸入端被以流的形式進行連接并合并成排過序的輸入，該策略適用于一個或兩個輸入端都已排過序的情況；

參考代碼：

import org.apache.flink.api.common.operators.base.JoinOperatorBase.JoinHint
import org.apache.flink.api.scala._

import scala.collection.mutable.ListBuffer

/**
 * @author 需求：
 *            請將以下元組資料(用戶 id,用戶姓名)
 *            (1, "zhangsan") ,
 *            (2, "lisi") ,
 *            (3 , "wangwu") ,
 *            (4 , "zhaoliu")
 *            元組資料(用戶 id,所在城市)
 *            (1, "beijing"),
 *            (2, "shanghai"),
 *            (4, "guangzhou")
 *            回傳如下資料：
 *            (3,wangwu,null)
 *            (1,zhangsan,beijing)
 *            (2,lisi,shanghai)
 *            (4,zhaoliu,guangzhou)
 * @date 2020/9/15 23:43
 * @version 1.0
 */
object BachFullOuterJoin {
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.創建要測驗的資料集
    val data1 = ListBuffer[Tuple2[Int, String]]()
    data1.append((1, "zhangsan"))
    data1.append((2, "lisi"))
    data1.append((3, "wangwu"))
    data1.append((4, "zhaoliu"))
    val data2 = ListBuffer[Tuple2[Int, String]]()
    data2.append((1, "beijing"))
    data2.append((2, "shanghai"))
    data2.append((4, "guangzhou"))
    //2.2 使用fromCollection構建資料集
    val test1 = env.fromCollection(data1)
    val test2 = env.fromCollection(data2)
    //3.使用fullOuterJoin 進行關聯
    val result = test1.fullOuterJoin(test2,JoinHint.REPARTITION_SORT_MERGE).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)
      }
    })
    //4.結果輸出
    result.print()
  }
}

14、cross

介紹： 和 join 類似，但是這種交叉操作會產生笛卡爾積，在資料比較大的時候，是非常消耗記憶體的操作；
示例： 請將以下元組資料 (1, 4, 7), (2, 5, 8), (3, 6, 9)
元組資料 (10, 40, 70), (20, 50, 80), (30, 60, 90)

進行笛卡爾積，回傳如下資料：

Buffer(((1,4,7),(10,40,70)), ((1,4,7),(20,50,80)), ((1,4,7),(30,60,90)), ((2,5,8),(10,40,70)), ((2,5,8),(20,50,80)), ((2,5,8),(30,60,90)), ((3,6,9),(10,40,70)), ((3,6,9),(20,50,80)), ((3,6,9),(30,60,90)))

參考代碼：


import org.apache.flink.api.scala._

/**
 * @author
 * @date 2020/9/15 23:50
 * @version 1.0
 */
object BatchCross {
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env: ExecutionEnvironment = ExecutionEnvironment.getExecutionEnvironment
    println("==============================cross=======================================")
    cross(env)
    println("==============================crossWithTiny=======================================")
    crossWithTiny(env)
    println("==============================crossWithHuge=======================================")
    crossWithHuge(env)
  }

  /**
   * 笛卡爾集
   *
   * @param env
   */
  def cross(env: ExecutionEnvironment) = {
    //1.使用 fromElements定義兩個dataSet
    val data1 = env.fromElements((1, 4, 7), (2, 5, 8), (3, 6, 9))
    val data2 = env.fromElements((10, 40, 70), (20, 50, 80), (30, 60, 90))
    val result = data1.cross(data2)
    println(result.collect())
  }

  /**
   * 暗示第二個輸入較小的交叉
   *
   * @param env
   */
  def crossWithTiny(env: ExecutionEnvironment) = {
    //1.定義 case class
    case class Coord(id: Int, x: Int, y: Int)
    val data1: DataSet[Coord] = env.fromElements( Coord(2, 5, 8), Coord(1, 4, 7),Coord(3, 6, 9))
    val data2: DataSet[Coord] = env.fromElements( Coord(20, 50, 80),Coord(10, 40, 70), Coord(30, 60, 90))
    val result = data1.crossWithTiny(data2)
    result.print()
  }

  def crossWithHuge(env: ExecutionEnvironment) = {
    //1.定義 case class
    case class Coord(id: Int, x: Int, y: Int)
    val data1: DataSet[Coord] = env.fromElements(Coord(1, 4, 7), Coord(2, 5, 8), Coord(3, 6, 9))
    val data2: DataSet[Coord] = env.fromElements(Coord(10, 40, 70), Coord(20, 50, 80), Coord(30, 60, 90))
    val result = data1.crossWithHuge(data2)
    result.print()
  }
}

15、Union

介紹： 將多個 DataSet 合并成一個 DataSet【注意】：union 合并的 DataSet 的型別必須是一致的
示例：
將以下資料進行取并集操作
資料集

1 “hadoop”, “hive”, “flume”

資料集 2

“hadoop”, “hive”, “spark”

實作步驟：

構建批處理運行環境
使用 fromCollection 創建兩個資料源
使用 union 將兩個資料源關聯在一起
列印測驗

參考代碼：

import org.apache.flink.api.scala._

/**
 * @author 需求：
 *         將以下資料進行取并集操作
 *         資料集
 *         1 "hadoop", "hive", "flume"
 *         資料集
 *         2 "hadoop", "hive", "spark
 * @date 2020/9/16 0:05
 * @version 1.0
 */
object BachUnion {
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.構建資料集
    val data1 = env.fromCollection(List("hadoop", "hive", "flume"))
    val data2 = env.fromCollection(List("hadoop", "hive", "spark"))
    val result = data1.union(data2)
    result.print()
  }
}

16、Rebalance（重點）

介紹：
Flink 也有資料傾斜的時候，比如當前有資料量大概 10 億條資料需要處理，在處理程序中可能會發生如圖所示的狀況：
在這里插入圖片描述
這個時候本來總體資料量只需要 10 分鐘解決的問題，出現了資料傾斜，機器 1 上的任務需要 4 個小時才能完成，那么其他 3 臺機器執行完畢也要等待機器 1 執行完畢后才算整體將任務完成；所以在實際的作業中，出現這種情況比較好的解決方案就是—rebalance（內部使用 round robin 方法將資料均勻打散，這對于資料傾斜時是很好的選擇，）
在這里插入圖片描述
實作步驟：

構建批處理運行環境
使用 env.generateSequence 創建 0-100 的并行資料
使用 fiter 過濾出來大于 8 的數字
使用 map 操作傳入 RichMapFunction ，將當前子任務的 ID 和數字構建成一個元組
在 RichMapFunction 中可以使用 getRuntimeContext.getIndexOfThisSubtask 獲取子任務序號
列印測驗

代碼實作：

import org.apache.flink.api.common.functions.RichMapFunction
import org.apache.flink.api.scala._

/**
 * @author 對資料集進行再平衡，重磁區，消除資料傾斜
 * @date 2020/9/16 0:21
 * @version 1.0
 */
object BatchRebalance {
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.構建資料集
    val data = env.generateSequence(0, 100)
    val ds = data.filter(_ > 8)
    //3.對資料進行在平衡操作
    val value1 = ds.rebalance().map(new RichMapFunction[Long, (Int, Long)] {
      override def map(value: Long): (Int, Long) = {
        (getRuntimeContext.getIndexOfThisSubtask, value)
      }
    })
    //4.結果輸出
    value1.print()
  }
}

17、First（重點）

介紹： 根據給定的 key 對一個資料集取前 N 條資料（往往在公司中是經常用到了，比如頭條中的熱搜Top10）
實作步驟：

構建批處理運行環境
使用 fromCollection 構建測驗資料集
使用 first 獲取前 N 條資料
列印測驗

參考代碼：

import org.apache.flink.api.common.operators.Order
import org.apache.flink.api.scala._

import scala.collection.mutable.ListBuffer

/**
 * @author  需求：根據給定的 key 對一個資料集取前 N 條資料
 * @date 2020/9/16 19:07
 * @version 1.0
 */
object BachFirst {
  def main(args: Array[String]): Unit = {
    //1.構建運行環境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.構建資料集
    val data = ListBuffer[Tuple2[Int,String]]()
    data.append((2,"zs"))
    data.append((4,"ls"))
    data.append((3,"ww"))
    data.append((1,"xw"))
    data.append((1,"aw"))
    data.append((1,"mw"))
    val text = env.fromCollection(data)
    //3.使用first去前三條資料
    val first = text.first(3)
    val sortFirst = text.sortPartition(0, Order.ASCENDING).sortPartition(1, Order.DESCENDING).first(3)
    //4.結果資料
    first.print()
    sortFirst.print()
  }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/76513.html

標籤：其他

上一篇：2020年第十七屆數模競賽F題飛行器質心平衡供油策略優化建模【分享交流】