Flink_DateSet 的 Transformation

最新推荐文章于 2024-07-01 02:25:02 发布
最新推荐文章于 2024-07-01 02:25:02 发布
阅读量446 收藏
点赞数
分类专栏： Flink 文章标签： Flink
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44509920/article/details/107434636
版权

文章目录

1. map 函数

在这里插入图片描述

参考代码

import org.apache.flink.api.scala.ExecutionEnvironment

/**
 * 需求：
 * 使用 map 操作， 将以下数据
 * "1,张三", "2,李四", "3,王五", "4,赵六"
 * 转换为一个 scala 的样例类。
 */
object BatchMapDemo {
  //3.创建样例类
  case class user(id:Int,name:String)
  def main(args: Array[String]): Unit = {
    //1.创建执行环境
    val env = ExecutionEnvironment.getExecutionEnvironment
    //2.构建数据集
    import org.apache.flink.api.scala._
    val sourceDataSet: DataSet[String] = env.fromElements("1,张三", "2,李四", "3,王五", "4,赵六")
    //4.数据转换处理
    val userDataSet: DataSet[user] = sourceDataSet.map(item => {
      val itemsArr: Array[String] = item.split(",")
      user(itemsArr(0).toInt, itemsArr(1))
    })
    //5.打印输出
    userDataSet.print()
  }
}

2. flatMap 函数

在这里插入图片描述
代码实现

import org.apache.flink.api.scala.ExecutionEnvironment
import scala.collection.mutable

object BatchFlatMapDemo {
  def main(args: Array[String]): Unit = {

    val env: ExecutionEnvironment = ExecutionEnvironment.getExecutionEnvironment
    import org.apache.flink.api.scala._
    val sourceDatSet: DataSet[String] = env.fromCollection(List(
      "张三,中国,江西省,南昌市",
      "李四,中国,河北省,石家庄市",
      "Tom,America,NewYork,Manhattan"
    ))
    val resultDataSet: DataSet[(String, String)] = sourceDatSet.flatMap(item => {
      val itemsArr: mutable.ArrayOps[String] = item.split(",")
      List(
        (itemsArr(0), itemsArr(1)),
        (itemsArr(0), itemsArr(1) + itemsArr(2)),
        (itemsArr(0), itemsArr(1) + itemsArr(2) + itemsArr(3))
      )
    })
    resultDataSet.print()
  }
}

3. mapPartition 函数

在这里插入图片描述
代码实现

package com.czxy.flink.batch.transfromation
import org.apache.flink.api.scala.ExecutionEnvironment

/**
 * 需求：
 * 使用 mapPartition 操作， 将以下数据
 * "1,张三", "2,李四", "3,王五", "4,赵六"
 * 转换为一个 scala 的样例类。
 */
object BatchMapPartitionDemo {

  case class user(id:Int,name:String)
  def main(args: Array[String]): Unit = {
    //1.创建执行环境
    val env: ExecutionEnvironment = ExecutionEnvironment.getExecutionEnvironment
    //2.构建数据集
    import org.apache.flink.api.scala._
    val sourceDataSet: DataSet[String] = env.fromElements("1,张三", "2,李四", "3,王五", "4,赵六")

    //3数据处理
    val userDataSet: DataSet[user] = sourceDataSet.mapPartition(itemPartition => {
      itemPartition.map(item => {
        val itemsArr: Array[String] = item.split(",")
        user(itemsArr(0).toInt, itemsArr(1))
      })
    })
    //4.打印数据
    userDataSet.print()
  }
}

4.filter 函数

在这里插入图片描述
代码实现

import org.apache.flink.api.scala.ExecutionEnvironment 
import org.apache.flink.api.scala._
/*** 过滤出来以下以 h 开头的单词。 * "hadoop", "hive", "spark", "flink" */

object BatchFilterDemo {
def main(args: Array[String]): Unit = {

val env = ExecutionEnvironment.getExecutionEnvironment

val textDataSet: DataSet[String] = env.fromElements("hadoop","hive", "spark", "flink")

val filterDataSet: DataSet[String] = textDataSet.filter(x=>x.startsWith("h"))

filterDataSet.print()
}
}

5. reduce 函数

在这里插入图片描述
代码实现

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

/*** 请将以下元组数据， 
* 使用 reduce 操作聚合成一个最终结果 ("java" , 1) , ("java", 1) ,("java" , 1)
* * 将上传元素数据转换为 ("java",3) */

object BatchReduceDemo {
def main(args: Array[String]): Unit = {

val env = ExecutionEnvironment.getExecutionEnvironment

val textDataSet: DataSet[(String, Int)] = env.fromCollection(List(("java" , 1),("java", 1),("java" , 1)))

val groupedDataSet: GroupedDataSet[(String, Int)] = textDataSet.groupBy(0)

val reduceDataSet: DataSet[(String, Int)] = groupedDataSet.reduce((v1, v2)=>(v1._1,v1._2+v2._2))

reduceDataSet.print()
}
}

6. reduceGroup

可以对一个 dataset 或者一个 group 来进行聚合计算，最终聚合成一个元素 reduce 和 reduceGroup 的 区别
在这里插入图片描述
在这里插入图片描述
代码实现

import org.apache.flink.api.scala.{DataSet, ExecutionEnvironment}
import org.apache.flink.api.scala._

/*** 请将以下元组数据，先按照单词使用 groupBy 进行分组， 
 再使用 reduceGroup 操作进行单词计数 
("java" , 1) , ("java", 1) ,("scala" , 1) 
 */ 

object BatchReduceGroupDemo {
def main(args: Array[String]): Unit = {

val env: ExecutionEnvironment = ExecutionEnvironment.getExecutionEnvironment

val textDataSet: DataSet[(String, Int)] = env.fromCollection(List(("java" , 1),("java", 1),("scala" , 1)))

val groupedDataSet: GroupedDataSet[(String, Int)] = textDataSet.groupBy(0)

val reduceGroupDataSet: DataSet[(String, Int)] = groupedDataSet.reduceGroup(group => { group.reduce((v1, v2) => { (v1._1, v1._2 + v2._2)
}) 
})
reduceGroupDataSet.print()
}
}

7. Aggregate

在这里插入图片描述
代码实现

import org.apache.flink.api.java.aggregation.Aggregations 
import org.apache.flink.api.scala._

/*** 请将以下元组数据，使用 aggregate 操作进行单词统计 
* ("java" , 1) , ("java", 1) ,("scala" , 1) 
* */

object BatchAggregateDemo {
def main(args: Array[String]): Unit = {

val env = ExecutionEnvironment.getExecutionEnvironment

val textDataSet = env.fromCollection(List(("java" , 1) , ("java", 1)

val grouped = textDataSet.groupBy(0)

val aggDataSet: AggregateDataSet[(String, Int)] = grouped.aggregate(Aggregations.MAX,1)

aggDataSet.print()
}
}

8. minBy 和 maxBy

在这里插入图片描述
代码实现

import org.apache.flink.api.java.aggregation.Aggregations 
import org.apache.flink.api.scala.{DataSet, ExecutionEnvironment} 
import scala.collection.mutable 
import scala.util.Random

object BatchMinByAndMaxBy { 
def main(args: Array[String]): Unit = { 
val env = ExecutionEnvironment.getExecutionEnvironment 

val data = new mutable.MutableList[(Int, String, Double)]
   data.+=((1, "yuwen", 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))

//导入隐式转换 
import org.apache.flink.api.scala._ 
//fromCollection将数据转化成DataSet 
val input: DataSet[(Int, String, Double)] = env.fromCollection(Random.shuffle(data)) 
input.print()
 println("===========获取指定字段分组后，某个字段的最大值 ==================") 
 val output = input.groupBy(1).aggregate(Aggregations.MAX, 2) 
 output.print()
  
  println("===========使用【MinBy】获取指定字段分组后，某个字段的最小值 ==================") 
  // val input: DataSet[(Int, String, Double)] = env.fromCollection(Random.shuffle(data)) 
  val output2: DataSet[(Int, String, Double)] = input.groupBy(1) 
  //求每个学科下的最小分数
   //minBy的参数代表要求哪个字段的最小值
.minBy(2) 
output2.print() 
println("===========使用【maxBy】获取指定字段分组后，某个字段的最大值 ==================") 
// val input: DataSet[(Int, String, Double)] = env.fromCollection(Random.shuffle(data)) 
val output3: DataSet[(Int, String, Double)] = input .groupBy(1) 
//求每个学科下的最小分数
 //minBy的参数代表要求哪个字段的最小值 
 .maxBy(2) 
 output3.print()

9. distinct 去重

在这里插入图片描述
代码实现

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

/**** 请将以下元组数据，使用 distinct 操作去除重复的单词 
** ("java" , 1) , ("java", 1) ,("scala" , 1) 
** 去重得到
** ("java", 1), ("scala", 1) **/

object BatchDistinctDemo { 
def main(args: Array[String]): Unit = { 
val env = ExecutionEnvironment.getExecutionEnvironment 
val textDataSet: DataSet[(String, Int)] = env.fromCollection(List(("java", 1), ("java", 1), ("scala", 1))) 
textDataSet.distinct(1).print()
}
}

10. Join

在这里插入图片描述
在这里插入图片描述
代码实现

import org.apache.flink.api.scala._ 
/**** 使用join可以将两个DataSet连接起来 **/
 object BatchJoinDemo { 
 case class Subject(id: Int, name: String) 
 case class Score(id: Int, stuName: String, subId: Int, score: Double) 
 def main(args: Array[String]): Unit = { 
 val env = ExecutionEnvironment.getExecutionEnvironment 
 val subjectDataSet: DataSet[Subject] = env.readCsvFile[Subject]("day01/data/input/subject.csv") 
 val scoreDataSet: DataSet[Score] = env.readCsvFile[Score]("day01/data/input/score.csv") 
 //join的替代方案：broadcast 
 val joinDataSet: JoinDataSet[Score, Subject] = scoreDataSet.join(subjectDataSet).where(_.subId).equalTo(_.id) 
 joinDataSet.print() } }

在这里插入图片描述

11. LeftOuterJoin

在这里插入图片描述
代码实现

import org.apache.flink.api.scala.ExecutionEnvironment 
import scala.collection.mutable.ListBuffer 
/*** 左外连接,左边的Dataset中的每一个元素，去连接右边的元素 */
 object BatchLeftOuterJoinDemo { 
 def main(args: Array[String]): Unit = { 
 val env = ExecutionEnvironment.getExecutionEnvironment 
 import org.apache.flink.api.scala._ 
 
 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")) 

val text1 = env.fromCollection(data1) 
val text2 = env.fromCollection(data2) 
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() 
  }
   }

12. RightOuterJoin

在这里插入图片描述
代码实现

import org.apache.flink.api.scala.ExecutionEnvironment 
import scala.collection.mutable.ListBuffer 
/*** 左外连接,左边的Dataset中的每一个元素，去连接右边的元素 */ 
object BatchLeftOuterJoinDemo { 
def main(args: Array[String]): Unit = { 

val env = ExecutionEnvironment.getExecutionEnvironment 
import org.apache.flink.api.scala._ 
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")) 

val text1 = env.fromCollection(data1) 
val text2 = env.fromCollection(data2) 

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

13. fullOuterJoin

在这里插入图片描述
代码实现

import org.apache.flink.api.common.operators.base.JoinOperatorBase.JoinHint 
import org.apache.flink.api.scala.{ExecutionEnvironment, _} 
import scala.collection.mutable.ListBuffer 
/**** 左外连接,左边的Dataset中的每一个元素，去连接右边的元素 **/ 

object BatchFullOuterJoinDemo {
def main(args: Array[String]): Unit = { 
val env = ExecutionEnvironment.getExecutionEnvironment 

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")) 

val text1 = env.fromCollection(data1)
 val text2 = env.fromCollection(data2) 
 /*** OPTIMIZER_CHOOSES：将选择权交予Flink优化器，相当于没有给提示； 
 * BROADCAST_HASH_FIRST：广播第一个输入端，同时基于它构建一个哈希表，而第 二个输入端作为探索端，选择这种策略的场景是第一个输入端规模很小； 
 * * BROADCAST_HASH_SECOND：广播第二个输入端并基于它构建哈希表，第一个输入端 作为探索端，选择这种策略的场景是第二个输入端的规模很小； 
 * * REPARTITION_HASH_FIRST：该策略会导致两个输入端都会被重分区，但会基于第 一个输入端构建哈希表。该策略适用于第一个输入端数据量小于第二个输入端的数据量，但这 两个输入端的规模仍然很大，优化器也是当没有办法估算大小，没有已 存在的分区以及排序 顺序可被使用时系统默认采用的策略； 
 * * REPARTITION_HASH_SECOND：该策略会导致两个输入端都会被重分区，但会基于 第二个输入端构建哈希表。该策略适用于两个输入端的规模都很大，但第二个输入端的数据量 小于第一个输入端的情况； 
 * * REPARTITION_SORT_MERGE：输入端被以流的形式进行连接并合并成排过序的输入。 该策略适用于一个或两个输入端都已 排过序的情况；
 *  */

 text1.fullOuterJoin(text2, 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) 
  } 
  }).print() 
}
}

14 .cross 交叉操作

在这里插入图片描述
代码实现

import org.apache.flink.api.scala.{DataSet, ExecutionEnvironment} 
import org.apache.flink.api.scala._ 
/**** 通过形成这个数据集和其他数据集的笛卡尔积，创建一个新的数据集。 **/
 object BatchCrossDemo { 
 def main(args: Array[String]): Unit = { 

val env = ExecutionEnvironment.getExecutionEnvironment 
println("============cross==================") 
cross(env) 
println("============cross2==================") 
cross2(env) 
println("============cross3==================") 
cross3(env) 
println("============crossWithTiny==================") crossWithTiny(env) println("============crossWithHuge==================") 
crossWithHuge(env) 
}
/**** @param benv *
 交叉。拿第一个输入的每一个元素和第二个输入的每一个元素进行交叉操作。 
 ** res71: Seq[((Int, Int, Int), (Int, Int, Int))] = Buffer( 
 * ((1,4,7),(10,40,70)), ((2,5,8),(10,40,70)), ((3,6,9),(10,40,70)), 
 * * ((1,4,7),(20,50,80)), ((2,5,8),(20,50,80)), ((3,6,9),(20,50,80)), 
 * * ((1,4,7),(30,60,90)), ((2,5,8),(30,60,90)), ((3,6,9),(30,60,90)))
*/ 
def cross(benv: ExecutionEnvironment): Unit = { 
//1.定义两个DataSet 
val coords1 = benv.fromElements((1, 4, 7), (2, 5, 8), (3, 6, 9)) 
val coords2 = benv.fromElements((10, 40, 70), (20, 50, 80), (30, 60, 90)) 
//2.交叉两个DataSet[Coord] 
val result1 = coords1.cross(coords2) 
//3.显示结果 
println(result1.collect)
 }
 
/**** @param benv * res69: Seq[(Coord, Coord)] = Buffer( 
* (Coord(1,4,7),Coord(10,40,70)), (Coord(2,5,8),Coord(10,40,70)), (Coord(3,6,9),Coord(10,40,70)), 
* * (Coord(1,4,7),Coord(20,50,80)), (Coord(2,5,8),Coord(20,50,80)), (Coord(3,6,9),Coord(20,50,80)), 
* * (Coord(1,4,7),Coord(30,60,90)), (Coord(2,5,8),Coord(30,60,90)), (Coord(3,6,9),Coord(30,60,90))) 
* */
 def cross2(benv: ExecutionEnvironment): Unit = { 
 //1.定义 case class 
 case class Coord(id: Int, x: Int, y: Int) 
 //2.定义两个DataSet[Coord] 
 val coords1: DataSet[Coord] = benv.fromElements( 
 Coord(1, 4, 7), 
 Coord(2, 5, 8), 
 Coord(3, 6, 9)) 

val coords2: DataSet[Coord] = benv.fromElements( 
Coord(10, 40, 70), 
Coord(20, 50, 80), 
Coord(30, 60, 90)) 

//3.交叉两个DataSet[Coord] 
val result1 = coords1.cross(coords2) 
//4.显示结果 
println(result1.collect) 
}

/**** @param benv ** res65: Seq[(Int, Int, Int)] = Buffer( 
* (1,1,22), (2,1,24), (3,1,26), 
* * (1,2,24), (2,2,26), (3,2,28),
* (1,3,26), (2,3,28), (3,3,30)) 
* */

 def cross3(benv: ExecutionEnvironment): Unit = {
  //1.定义 case class 
  case class Coord(id: Int, x: Int, y: Int) 
  //2.定义两个DataSet[Coord] 
  val coords1: DataSet[Coord] = benv.fromElements( 
  Coord(1, 4, 7), 
  Coord(2, 5, 8), 
  Coord(3, 6, 9)) 
  
  val coords2: DataSet[Coord] = benv.fromElements( 
  Coord(1, 4, 7), 
  Coord(2, 5, 8), 
  Coord(3, 6, 9)) 

//3.交叉两个DataSet[Coord]，使用自定义方法 
val r = coords1.cross(coords2) { (c1, c2) => { 
val dist = (c1.x + c2.x) + (c1.y + c2.y) (c1.id, c2.id, dist) 
}
}

//4.显示结果 
println(r.collect) 
}

/**** 暗示第二个输入较小的交叉。 
** 拿第一个输入的每一个元素和第二个输入的每一个元素进行交叉操作。 
** @param benv ** res67: Seq[(Coord, Coord)] = Buffer( 
** (Coord(1,4,7),Coord(10,40,70)), (Coord(1,4,7),Coord(20,50,80)), (Coord(1,4,7),Coord(30,60,90)), 
** (Coord(2,5,8),Coord(10,40,70)), (Coord(2,5,8),Coord(20,50,80)), (Coord(2,5,8),Coord(30,60,90)), 
** (Coord(3,6,9),Coord(10,40,70)), (Coord(3,6,9),Coord(20,50,80)), (Coord(3,6,9),Coord(30,60,90))) 
**/


def crossWithTiny(benv: ExecutionEnvironment): Unit = { 
//1.定义 case class 
case class Coord(id: Int, x: Int, y: Int)
 //2.定义两个DataSet[Coord] 
 val coords1: DataSet[Coord] = benv.fromElements( 
 Coord(1, 4, 7), 
 Coord(2, 5, 8), 
 Coord(3, 6, 9)) 
 
 val coords2: DataSet[Coord] = benv.fromElements( 
 Coord(10, 40, 70), 
 Coord(20, 50, 80),
  Coord(30, 60, 90)) 

//3.交叉两个DataSet[Coord]，暗示第二个输入较小 
val result1 = coords1.crossWithTiny(coords2) 

//4.显示结果
 println(result1.collect) 
 }
 /****** @param benv ** 暗示第二个输入较大的交叉。
  ** 拿第一个输入的每一个元素和第二个输入的每一个元素进行交叉操作。
   * res68: Seq[(Coord, Coord)] = Buffer( * (Coord(1,4,7),Coord(10,40,70)), (Coord(2,5,8),Coord(10,40,70)), (Coord(3,6,9),Coord(10,40,70)), 
   * * (Coord(1,4,7),Coord(20,50,80)), (Coord(2,5,8),Coord(20,50,80)), (Coord(3,6,9),Coord(20,50,80)),
   *  * (Coord(1,4,7),Coord(30,60,90)), (Coord(2,5,8),Coord(30,60,90)), (Coord(3,6,9),Coord(30,60,90))) 
   * **/ 


def crossWithHuge(benv: ExecutionEnvironment): Unit = { 
//1.定义 case class 
case class Coord(id: Int, x: Int, y: Int) 
//2.定义两个DataSet[Coord] 
val coords1: DataSet[Coord] = benv.fromElements(
 Coord(1, 4, 7), 
 Coord(2, 5, 8), 
 Coord(3, 6, 9)) 

val coords2: DataSet[Coord] = benv.fromElements(
 Coord(10, 40, 70),
Coord(20, 50, 80), 
Coord(30, 60, 90)) 
//3.交叉两个DataSet[Coord]，暗示第二个输入较大 
val result1 = coords1.crossWithHuge(coords2) 

//4.显示结果 
println(result1.collect) 
} 
}

15. Union

在这里插入图片描述
代码实现

import org.apache.flink.api.scala._ 
/*** 将两个DataSet取并集，并不会进行去重。 */ 

object BatchUnionDemo { 
def main(args: Array[String]): Unit = { 

val env = ExecutionEnvironment.getExecutionEnvironment 
// 使用`fromCollection`创建两个数据源 
val wordDataSet1 = env.fromCollection(List("hadoop", "hive", "flume")) 
val wordDataSet2 = env.fromCollection(List("hadoop", "hive", "spark")) 
val wordDataSet3 = env.fromElements("hadoop") 
val wordDataSet4 = env.fromElements("hadoop") 
wordDataSet1.union(wordDataSet2).print() 
wordDataSet3.union(wordDataSet4).print() 
} 
}

16. Rebalance

在这里插入图片描述
在这里插入图片描述
代码实现

import org.apache.flink.api.common.functions.RichMapFunction 
import org.apache.flink.api.scala.ExecutionEnvironment 
import org.apache.flink.api.scala._ 
/**** 对数据集进行再平衡，重分区，消除数据倾斜 **/ 
object BatchRebalanceDemo { 
def main(args: Array[String]): Unit = { 

val env = ExecutionEnvironment.getExecutionEnvironment 
val ds = env.generateSequence(0, 100) 
val rebalanced = ds.filter(_ > 8) 
// val rebalanced = skewed.rebalance() 
val countsInPartition = rebalanced.map(new RichMapFunction[Long, (Int, Long)] { def map(in: Long) = { 
//获取并行时子任务的编号getRuntimeContext.getIndexOfThisSubtask
(getRuntimeContext.getIndexOfThisSubtask, in) 
}
 })
 countsInPartition.print() 
 } 
 }

2：使用 rebalance

import org.apache.flink.api.common.functions.RichMapFunction 
import org.apache.flink.api.scala.ExecutionEnvironment 
import org.apache.flink.api.scala._ 
/**** 对数据集进行再平衡，重分区，消除数据倾斜 **/ 
object BatchDemoRebalance2 { 
def main(args: Array[String]): Unit = { 

val env = ExecutionEnvironment.getExecutionEnvironment 
//TODO rebalance 
val ds = env.generateSequence(1, 3000) 
val skewed = ds.filter(_ > 780) 
val rebalanced = skewed.rebalance() 
val countsInPartition = rebalanced.map( new RichMapFunction[Long, (Int, Long)] { 
def map(in: Long) = { 
//获取并行时子任务的编号 getRuntimeContext.getIndexOfThisSubtask 
(getRuntimeContext.getIndexOfThisSubtask, in) 
}
 }) 
 countsInPartition.print() 
 } 
 }

17 .First

在这里插入图片描述
代码实现

import org.apache.flink.api.common.operators.Order 
import org.apache.flink.api.scala.ExecutionEnvironment 
import scala.collection.mutable.ListBuffer 

object BatchFirstNDemo { 
def main(args: Array[String]): Unit = {

val env=ExecutionEnvironment.getExecutionEnvironment 

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

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条数据，按照数据插入的顺序 
      text.first(3).print() 
      println("==============================") 
      //根据数据中的第一列进行分组，获取每组的前2个元素 
      text.groupBy(0).first(2).print() 
      println("==============================") 
      //根据数据中的第一列分组，再根据第二列进行组内排序[升序]，获取每组的前2个元素 
      text.groupBy(0).sortGroup(1,Order.ASCENDING).first(2).print() 
      println("==============================") 
      //不分组，全局排序获取集合中的前3个元素， 
      text.sortPartition(0,Order.ASCENDING).sortPartition(1,Order.DESCENDIN G).first(3).print() 
      } 
      }
BigMoM1573
关注
专栏目录
flink的DataSet算子讲解
qq_34841911的博客
03-05 6406
本文是已官方文档 为基础进行个人解释，有错误地方还望多多包涵：https://ci.apache.org/projects/flink/flink-docs-release-1.3/api/scala/index.html#org.apache.flink.api.scala.DataSet首先启动flink集群模式，再启动./start-scala-shell.sh remote master ...
Flink的DataSet基本算子总结_flink dateset 算子详解
2301_79985178的博客
04-26 430
);//获取运行环境});//去掉重复的单词//选出长度大于3的单词}).print();//获取运行的环境//创建第一张表：用户ID 姓名//创建第二张表：用户ID 所在的城市data2.add(new Tuple2(1,“北京”));data2.add(new Tuple2(2,“上海”));data2.add(new Tuple2(3,“广州”));
Flink 常用的 DataSet 和 DataStream API
zsyoung的博客
07-11 719
说好的流批一体呢？ 现状是截止1.10版本依然采用了 DataSet 和 DataStream 两套 API 来适配不同的应用场景。 DateSet 和 DataStream 的区别和联系 1、Apache Flink 在诞生之初的设计哲学是：用同一个引擎支持多种形式的计算，包括批处理、流处理和机器学习等。尤其是在流式计算方面，Flink 实现了计算引擎级别的流批一体 ​2、对于DataSet而言，Source部分来源于文件、表或者Java集合 3、对于DataStream而言，Source
[flink]#13_Data Set
PigCircle
10-31 106
DataSource 基于集合 fromCollection(Collection) 基于文件 readTextFile(path) Transformation Map FlatMap MapPartition: 一次处理一个分区的数据 Filter Reduce Aggregations Distinct: 返回数据集中去重后的元素 Join O...
利用Flink SQL实时统计单据状态（含历史数据）
东境物语
08-01 8996
利用Flink SQL实时统计单据状态（含历史数据）
Flink基本概念和编程模型
技术大神之路
06-03 217
数据分类 有界数据，无界数据，其实没有必要，分为流数据和静态数据还差不多。 Flink 编程接口 高级语言：SQL 声明式API Table API 核心API DataStream/DateSet API 低级构建模块 Stateful Stream Processing Flink程序结构 第一步是获取ENV，StreamExecutionEnvironment是流式环境，而ExecutionEnvironment是批处理环境。 有三种获取env的方式，以StreamExecutionEnvironme
[Flink]一、Flink1.13
最新发布
weixin_44428807的博客
07-01 1055
1. Flink简介1.1 Flink的起源和设计理念flink项目的核心目标：数据流上的有状态计算（Stateful Computations over Data Streams)。时间驱动：来一个事件处理一个事件；流处理的流水线；流&批数据分析具体定位是：Apache Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。Flink 被设计在所有常见的集群环境中运行，以内存执行速度和任意规模来执行计算。1.2 Flink的应用。
Flink批量处理之DataSet
TU_JCN的博客
08-20 1289
Flink批量处理之DataSet flink不仅可以支持实时流式处理，它也可以支持批量处理，其中批量处理也可以看作是实时处理的一个特殊情况 1、dataSet的内置数据源 基于文件数据源 readTextFile(path) / TextInputFormat：逐行读取文件并将其作为字符串(String)返回 readTextFileWithValue(path) / TextValueInputFormat：逐行读取文件并将其作为StringValue返回。StringValue是Flink对Stri
Flink学习笔记
君永夜
08-27 1704
前言：Flink是当前主流的实时计算框架，阿里的Blink重构了Flink即能做全量数据的批处理，也能做增量数据的实时处理；大数据的业务数据处理分为两个步骤：全量数据批计算，以及增量数据的实时计算，有时处理的业务逻辑是一致的但是代码确是两套，繁琐；当前主流的大数据实时计算框架有： Spark Streming、Kafka Streaming、Storm、Flink、Blink（阿里双十二的主流实时...
Flink自学教程
热门推荐
weixin_43342277的博客
10-05 2万+
Flink自学教程 1.1.Flink的引入 这几年大数据的飞速发展，出现了很多热门的开源社区，其中著名的有 Hadoop、Storm，以及后来的 Spark，他们都有着各自专注的应用场景。Spark 掀开了内存计算的先河，也以内存为赌注，赢得了内存计算的飞速发展。Spark 的火热或多或少的掩盖了其他分布式计算的系统身影。就像 Flink，也就在这个时候默默的发展着。 在国外一些社区，有很多人将...
Flink笔记8：Flink流处理API之支持的数据类型和UDF 函数
Cape_sir
12-07 274
1、支持的数据类型 Flink 流应用程序处理的是以数据对象表示的事件流。所以在Flink 内部，我们需要能够处理这些对象。它们需要被序列化和反序列化，以便通过网络传送它们；或者从状态后端、检查点和保存点读取它们。为了有效地做到这一点，Flink 需要明确知道应用程序所处理的数据类型。Flink 使用类型信息的概念来表示数据类型，并为每个数据类型生成特定的序列化器、反序列化器和比较器。 Flink 还具有一个类型提取系统，该系统分析函数的输入和返回类型，以自动获取类型信息，从而获得序列化器和反序列化器。但是
关于flink的setCommitOffsetsOnCheckpoints
微电子学与固体电子学-俞驰
03-16 4145
提交 offset 到 kafka,一般都是作为外部进度的监控,想实时知道作业消费的位置和 lag 情况 如果启用了 checkpoint，但是禁用 CommitOffsetsOnCheckpoints， kafka 消费组的 offset 不会提交到 kafka，也就是说： 消费组的 offset 是不会有变化的 用法示例: //创建kafka数据流 val properties = new Properties() properties.setProperty("bootstrap.ser.
flink实战教程-使用set实时计算当天网站uv
公众号[大数据技术与应用实战]，分享大数据实战案例
06-21 1452
文章目录背景案例讲解模拟source定义窗口自定义聚合算子处理输出结果 背景 对于web网站，我们一般会有这样的需求，实时的计算出来当天网站的uv，尽可能快的展示出来。今天我们就讲一下基于java的set集合做一下实时uv的统计。 简易需求： 实时计算出当天零点截止到当前时间各个端(android,ios,h5)下的uv 每秒钟更新一次统计结果 案例讲解 模拟source 首先我们模拟生成一下最简单的数据，生成一个flink的二元组Tuple2.分别表示分类和用户id public static c
MYSQL函数 小记：DATEDIFF,TIMESTAMPDIFF,DATE_SUB
xinji
01-03 498
DATEDIFF 计算日期差 –注：返回值是相差的天数，不能定位到小时、分钟和秒 mysql> select DATEDIFF(A.modtime,NOW()),A.* from SYS_AREA A; +---------------------------+--------+---------+------------+---------+---------+------------...
Flink流式计算从入门到实战 三
roykingw的专栏
10-08 1999
文章目录四、Flink DataStream API1、Flink程序的基础运行模型2、Environment 运行环境3、Source3.1 基于File的数据源3.2 基于Socket的数据源3.3 基于集合的数据源3.4 从Kafka读取数据3.5 自定义Source4、Sink4.1 输出到到控制台4.2 输出到文件4.3 输出到Socket4.4 输出到kafka4.5 自定义Sink5、Transformation5.1 Map5.2 FlatMap5.3 filter 过滤5.4 keyBy5
Apache Flink 如何处理实时场景中的乱序数据
天道酬勤
12-01 1174
一、流式计算的未来 在谷歌发表了 GFS、BigTable、Google MapReduce 三篇论文后，大数据技术真正有了第一次飞跃，Hadoop 生态系统逐渐发展起来。 Hadoop 在处理大批量数据时表现非常好，主要有以下特点： 计算开始之前，数据必须提前准备好，然后才可以开始计算； 当大量数据计算完成之后，会输出最后计算结果，完成计算； 时效性比较低，不适用于实时计算； 而随着实时推荐、风控等业务的发展，数据处理时延要求越来越高，实时性要求也越来越高，Flink 开始在社区崭露头角。 Apach
mysql中date_add与date_sub函数使用详解
stay hungry ! stay foolish!
11-18 4181
           mysql中date_add与date_sub函数使用详解   转载：http://www.111cn.net/database/mysql/52936.htm 在mysql中date_add与date_sub函数分别date_add是对日期加减操作而date_sub是从日期减去指定的时间间隔了，下面我来介绍几个实例大家一起看看 mysql 中 DATE_ADD(d...
flink dataset join笔记
b078109的专栏
06-23 330
1、dataset的join连接，通过key进行关联，一般情况下的join都是inner join，类似sql里的inner join key包括以下几种情况： a key expression a key-selector function one or more field position keys (Tuple DataSet only). Case Class F...
flink内置函数
knowfarhhy
09-19 2万+
flink内置函数 flink支持的字符串函数： string1 || string2 : 两个字符串串联 CHAR_LENGTH(string) / CHARACTER_LENGTH(string) ：返回字符串字符长度 UPPER(string) ： 返回大写格式的字符串 LOWER(string) ： 返回小写格式的字符串 POSITION(string1 IN string2) ： 返回s...
FLINK_DIST_JAR
04-04
FLINK_DIST_JAR是Apache Flink的分发JAR文件。它是一个包含了Flink运行时和所有依赖项的可执行JAR文件。通过使用FLINK_DIST_JAR，您可以在不同的环境中部署和运行Flink应用程序。 以下是一个使用FLINK_DIST_JAR的示例命令行启动Flink应用程序的步骤： 1. 首先，确保您已经安装了Java和Flink，并且已经设置了相应的环境变量。 2. 找到您的Flink应用程序的JAR文件，例如"myflinkapp.jar"。 3. 使用以下命令行启动Flink应用程序： ```shell flink run -m <Flink Master URL> -c <Main Class> <Path to FLINK_DIST_JAR> <Path to Application JAR> ``` 其中： - `<Flink Master URL>`是Flink集群的主节点URL。 - `<Main Class>`是您的应用程序的主类。 - `<Path to FLINK_DIST_JAR>`是FLINK_DIST_JAR文件的路径。 - `<Path to Application JAR>`是您的应用程序JAR文件的路径。 这样，Flink将使用FLINK_DIST_JAR来分发和执行您的应用程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值