Flink DataStream 算子 Map、FlatMap、Filter、KeyBy、Reduce、Fold、Aggregate

最新推荐文章于 2024-04-05 15:29:09 发布
最新推荐文章于 2024-04-05 15:29:09 发布
阅读量1.3k 收藏 2
点赞数 1
分类专栏： java
原文链接：https://blog.csdn.net/wangpei1949/article/details/101625394
版权

总结Flink DataStream 算子: Map、FlatMap、Filter、KeyBy、Reduce、Fold、Aggregate 的使用。

Map [DataStream->DataStream]
Map: 一对一转换,即一条转换成另一条。

package com.bigdata.flink.dataStreamMapOperator;

import com.bigdata.flink.beans.UserAction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import java.util.Arrays;

/**
 * Summary:
 *      Map: 一对一转换
 */
public class DataStreamMapOperator {
    public static void main(String[] args) throws Exception{

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 输入: 用户行为。某个用户在某个时刻点击或浏览了某个商品，以及商品的价格。
        DataStreamSource<UserAction> source = env.fromCollection(Arrays.asList(
                new UserAction("userID1", 1293984000, "click", "productID1", 10),
                new UserAction("userID2", 1293984001, "browse", "productID2", 8),
                new UserAction("userID1", 1293984002, "click", "productID1", 10)
        ));

        // 转换: 商品的价格乘以8
        SingleOutputStreamOperator<UserAction> result = source.map(new MapFunction<UserAction, UserAction>() {
            @Override
            public UserAction map(UserAction value) throws Exception {

                int newPrice = value.getProductPrice() * 8;
                return new UserAction(value.getUserID(), value.getEventTime(), value.getEventType(), value.getProductID(), newPrice);
            }
        });

        // 输出: 输出到控制台
        // UserAction(userID=userID1, eventTime=1293984002, eventType=click, productID=productID1, productPrice=80)
        // UserAction(userID=userID1, eventTime=1293984000, eventType=click, productID=productID1, productPrice=80)
        // UserAction(userID=userID2, eventTime=1293984001, eventType=browse, productID=productID2, productPrice=64)
        result.print();

        env.execute();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
FlatMap [DataStream->DataStream]
FlatMap: 一行变零到多行。如下，将一个句子(一行)分割成多个单词(多行)。

package com.bigdata.flink.dataStreamFlatMapOperator;

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

/**
 * Summary:
 *      FlatMap: 一行变任意行(0~多行)
 */
public class DataStreamFlatMapOperator {
  public static void main(String[] args) throws Exception{
      StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

      // 输入: 英文电影台词
      DataStreamSource<String> source = env
              .fromElements(
                      "You jump I jump",
                      "Life was like a box of chocolates"
              );

      // 转换: 将包含chocolates的句子转换为每行一个单词
      SingleOutputStreamOperator<String> result = source.flatMap(new FlatMapFunction<String, String>() {
          @Override
          public void flatMap(String value, Collector<String> out) throws Exception {
              if(value.contains("chocolates")){
                  String[] words = value.split(" ");
                  for (String word : words) {
                      out.collect(word);
                  }
              }
          }
      });

      // 输出: 输出到控制台
      // Life
      // was
      // like
      // a
      // box
      // of
      // chocolates
      result.print();

      env.execute();
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
Filter [DataStream->DataStream]
Filter: 过滤出需要的数据

package com.bigdata.flink.dataStreamFilterOperator;

import com.bigdata.flink.beans.UserAction;
import org.apache.flink.api.common.functions.FilterFunction;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import java.util.Arrays;

/**
 * Summary:
 *      Fliter: 过滤出需要的数据
 */
public class DataStreamFilterOperator {
    public static void main(String[] args) throws Exception{

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 输入: 用户行为。某个用户在某个时刻点击或浏览了某个商品，以及商品的价格。
        DataStreamSource<UserAction> source = env.fromCollection(Arrays.asList(
                new UserAction("userID1", 1293984000, "click", "productID1", 10),
                new UserAction("userID2", 1293984001, "browse", "productID2", 8),
                new UserAction("userID1", 1293984002, "click", "productID1", 10)
        ));

        // 过滤: 过滤出用户ID为userID1的用户行为
        SingleOutputStreamOperator<UserAction> result = source.filter(new FilterFunction<UserAction>() {
            @Override
            public boolean filter(UserAction value) throws Exception {
                return value.getUserID().equals("userID1");
            }
        });

        // 输出: 输出到控制台
        // UserAction(userID=userID1, eventTime=1293984002, eventType=click, productID=productID1, productPrice=10)
        // UserAction(userID=userID1, eventTime=1293984000, eventType=click, productID=productID1, productPrice=10)
        result.print();

        env.execute();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
KeyBy [DataStream->KeyedStream]
KeyBy: 按指定的Key对数据重分区。将同一Key的数据放到同一个分区。

注意:

分区结果和KeyBy下游算子的并行度强相关。如下游算子只有一个并行度,不管怎么分，都会分到一起。
对于POJO类型，KeyBy可以通过keyBy(fieldName)指定字段进行分区。
对于Tuple类型，KeyBy可以通过keyBy(fieldPosition)指定字段进行分区。
对于一般类型，如上, KeyBy可以通过keyBy(new KeySelector {...})指定字段进行分区。
package com.bigdata.flink.dataStreamKeyByOperator;

import com.bigdata.flink.beans.UserAction;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import java.util.Arrays;

/**
 * Summary:
 *      KeyBy: 按指定的Key对数据重分区。将同一Key的数据放到同一个分区。
 */
public class DataStreamKeyByOperator {
    public static void main(String[] args) throws Exception{

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // 输入: 用户行为。某个用户在某个时刻点击或浏览了某个商品，以及商品的价格。
        DataStreamSource<UserAction> source = env.fromCollection(Arrays.asList(
                new UserAction("userID1", 1293984000, "click", "productID1", 10),
                new UserAction("userID2", 1293984001, "browse", "productID2", 8),
                new UserAction("userID1", 1293984002, "click", "productID1", 10)
        ));

        // 转换: 按指定的Key(这里,用户ID)对数据重分区，将相同Key(用户ID)的数据分到同一个分区
        KeyedStream<UserAction, String> result = source.keyBy(new KeySelector<UserAction, String>() {
            @Override
            public String getKey(UserAction value) throws Exception {
                return value.getUserID();
            }
        });

        // 输出: 输出到控制台
        //3> UserAction(userID=userID1, eventTime=1293984000, eventType=click, productID=productID1, productPrice=10)
        //3> UserAction(userID=userID1, eventTime=1293984002, eventType=click, productID=productID1, productPrice=10)
        //2> UserAction(userID=userID2, eventTime=1293984001, eventType=browse, productID=productID2, productPrice=8)
        result.print().setParallelism(3);

        env.execute();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
Reduce [KeyedStream->DataStream]
Reduce: 基于ReduceFunction进行滚动聚合，并向下游算子输出每次滚动聚合后的结果。
注意: Reduce会输出每一次滚动聚合的结果。

package com.bigdata.flink.dataStreamReduceOperator;

import com.bigdata.flink.beans.UserAction;
import org.apache.flink.api.common.functions.ReduceFunction;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import java.util.Arrays;

/**
 * Summary:
 *     Reduce: 基于ReduceFunction进行滚动聚合，并向下游算子输出每次滚动聚合后的结果。
 */
public class DataStreamReduceOperator {
    public static void main(String[] args) throws Exception{

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 输入: 用户行为。某个用户在某个时刻点击或浏览了某个商品，以及商品的价格。
        DataStreamSource<UserAction> source = env.fromCollection(Arrays.asList(
                new UserAction("userID1", 1293984000, "click", "productID1", 10),
                new UserAction("userID2", 1293984001, "browse", "productID2", 8),
                new UserAction("userID2", 1293984002, "browse", "productID2", 8),
                new UserAction("userID2", 1293984003, "browse", "productID2", 8),
                new UserAction("userID1", 1293984002, "click", "productID1", 10),
                new UserAction("userID1", 1293984003, "click", "productID3", 10),
                new UserAction("userID1", 1293984004, "click", "productID1", 10)
        ));

        // 转换: KeyBy对数据重分区
        KeyedStream<UserAction, String> keyedStream = source.keyBy(new KeySelector<UserAction, String>() {
            @Override
            public String getKey(UserAction value) throws Exception {
                return value.getUserID();
            }
        });

        // 转换: Reduce滚动聚合。这里,滚动聚合每个用户对应的商品总价格。
        SingleOutputStreamOperator<UserAction> result = keyedStream.reduce(new ReduceFunction<UserAction>() {
            @Override
            public UserAction reduce(UserAction value1, UserAction value2) throws Exception {
                int newProductPrice = value1.getProductPrice() + value2.getProductPrice();
                return new UserAction(value1.getUserID(), -1, "", "", newProductPrice);
            }
        });

        // 输出: 将每次滚动聚合后的结果输出到控制台。
        //3> UserAction(userID=userID2, eventTime=1293984001, eventType=browse, productID=productID2, productPrice=8)
        //3> UserAction(userID=userID2, eventTime=-1, eventType=, productID=, productPrice=16)
        //3> UserAction(userID=userID2, eventTime=-1, eventType=, productID=, productPrice=24)
        //4> UserAction(userID=userID1, eventTime=1293984000, eventType=click, productID=productID1, productPrice=10)
        //4> UserAction(userID=userID1, eventTime=-1, eventType=, productID=, productPrice=20)
        //4> UserAction(userID=userID1, eventTime=-1, eventType=, productID=, productPrice=30)
        //4> UserAction(userID=userID1, eventTime=-1, eventType=, productID=, productPrice=40)
        result.print();

        env.execute();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
Fold [KeyedStream->DataStream]
基于初始值和FoldFunction进行滚动折叠(Fold)，并向下游算子输出每次滚动折叠后的结果。
注意: Fold会输出每一次滚动折叠的结果。

package com.bigdata.flink.dataStreamFoldOperator;

import com.bigdata.flink.beans.UserAction;
import org.apache.flink.api.common.functions.FoldFunction;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import java.util.Arrays;

/**
 * Summary:
 *      Fold: 基于初始值和自定义的FoldFunction滚动折叠后发出新值
 */
public class DataStreamFoldOperator {
    public static void main(String[] args) throws Exception{

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 输入: 用户行为。某个用户在某个时刻点击或浏览了某个商品，以及商品的价格。
        DataStreamSource<UserAction> source = env.fromCollection(Arrays.asList(
                new UserAction("userID1", 1293984000, "click", "productID1", 10),
                new UserAction("userID2", 1293984001, "browse", "productID2", 8),
                new UserAction("userID2", 1293984002, "browse", "productID2", 8),
                new UserAction("userID2", 1293984003, "browse", "productID2", 8),
                new UserAction("userID1", 1293984002, "click", "productID1", 10),
                new UserAction("userID1", 1293984003, "click", "productID3", 10),
                new UserAction("userID1", 1293984004, "click", "productID1", 10)
        ));

        // 转换: KeyBy对数据重分区
        KeyedStream<UserAction, String> keyedStream = source.keyBy(new KeySelector<UserAction, String>() {
            @Override
            public String getKey(UserAction value) throws Exception {
                return value.getUserID();
            }
        });

        // 转换: Fold 基于初始值和FoldFunction滚动折叠
        SingleOutputStreamOperator<String> result = keyedStream.fold("浏览的商品及价格:", new FoldFunction<UserAction, String>() {
            @Override
            public String fold(String accumulator, UserAction value) throws Exception {
                if(accumulator.startsWith("userID")){
                    return accumulator + " -> " + value.getProductID()+":"+value.getProductPrice();
                }else {
                    return value.getUserID()+" " +accumulator + " -> " + value.getProductID()+":"+value.getProductPrice();
                }
            }
        });

        // 输出: 输出到控制台
        // 每一条数据都会触发计算并输出
        // userID1 浏览的商品及价格: -> productID1:10
        // userID1 浏览的商品及价格: -> productID1:10 -> productID1:10
        // userID1 浏览的商品及价格: -> productID1:10 -> productID1:10 -> productID3:10
        // userID1 浏览的商品及价格: -> productID1:10 -> productID1:10 -> productID3:10 -> productID1:10
        // userID2 浏览的商品及价格: -> productID2:8
        // userID2 浏览的商品及价格: -> productID2:8 -> productID2:8
        // userID2 浏览的商品及价格: -> productID2:8 -> productID2:8 -> productID2:8
        result.print();

        env.execute();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
Aggregate [KeyedStream->DataStream]
Aggregate 对KeyedStream按指定字段滚动聚合并输出每一次滚动聚合后的结果。默认的聚合函数有:sum、min、minBy、max、mabBy。

注意:

max(field)与maxBy(field)的区别: maxBy返回field最大的那条数据;而max则是将最大的field的值赋值给第一条数据并返回第一条数据。同理,min与minBy。
Aggregate聚合算子会滚动输出每一次聚合后的结果。
package com.bigdata.flink.dataStreamAggregateOperator;

import com.bigdata.flink.beans.UserActionLogPOJO;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import java.util.ArrayList;

/**
 * Summary:
 *     Aggregate: min()、minBy()、max()、maxBy() 滚动聚合并输出每次滚动聚合后的结果
 */
public class DataStreamAggregateOperator {
    public static void main(String[] args) throws Exception{

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 输入: 用户行为。某个用户在某个时刻点击或浏览了某个商品，以及商品的价格。
        ArrayList<UserActionLogPOJO> userActionLogs = new ArrayList<>();
        UserActionLogPOJO userActionLog1 = new UserActionLogPOJO();
        userActionLog1.setUserID("userID1");
        userActionLog1.setProductID("productID3");
        userActionLog1.setProductPrice(10);
        userActionLogs.add(userActionLog1);

        UserActionLogPOJO userActionLog2 = new UserActionLogPOJO();
        userActionLog2.setUserID("userID2");
        userActionLog2.setProductPrice(10);
        userActionLogs.add(userActionLog2);

        UserActionLogPOJO userActionLog3 = new UserActionLogPOJO();
        userActionLog3.setUserID("userID1");
        userActionLog3.setProductID("productID5");
        userActionLog3.setProductPrice(30);
        userActionLogs.add(userActionLog3);

        DataStreamSource<UserActionLogPOJO> source = env.fromCollection(userActionLogs);

        // 转换: KeyBy对数据重分区
        // 这里, UserActionLog是POJO类型,也可通过keyBy("userID")进行分区
        KeyedStream<UserActionLogPOJO, String> keyedStream = source.keyBy(new KeySelector<UserActionLogPOJO, String>() {
            @Override
            public String getKey(UserActionLogPOJO value) throws Exception {
                return value.getUserID();
            }
        });

        // 转换: Aggregate并输出
        // 滚动求和并输出
        //keyedStream.sum("productPrice").print();
        // 滚动求最大值并输出
        keyedStream.max("productPrice").print();
        // 滚动求最大值并输出
        keyedStream.maxBy("productPrice").print();
        // 滚动求最小值并输出
        //keyedStream.min("productPrice").print();
        // 滚动求最小值并输出
        //keyedStream.minBy("productPrice").print();

        env.execute();
    }
}
————————————————
版权声明：本文为CSDN博主「wangpei1949」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/wangpei1949/article/details/101625394

LzwGlory
关注
专栏目录
Flink reduce与fold 相同点和不同点(区别)
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
06-18 1936
相同点： 1 均是对相同类型的元素进行合并 2 均是把组内的所有元素合并成一个值 不同点： 1 reduce是组内的2个元素合并成一个同类型的新元素；fold是组内的每个元素与累加器（一开始是初始值initialValue）合并再返回累加器，累加器的类型可以与组内的元素类型不一致； 2 reduce可以用于DataStream或DataSet，但是fold只能用于DataStream。 Flink reduce 作用 实例 Flink fold算子 实例 （所有订单的分类汇总信息） 以下是源
Flink Transformation 操作
数据人生
07-04 525
前面我们介绍了Flink DataStream数据处理流程中的source和sink，这篇文章我们介绍一下 Flink的Transformation 的操作，一般常用的算子有下面几种，我们分别用代码来演示下他基本用法： Map操作 val stream = env.generateSequence(1, 5) //简单的map操作 //val streamMap = stream.map(item => item * 3) //复杂的map操作 val streamMap = stre...
flink深入研究(11) DataStream类中flatMap函数调用流程
weixin_39935887的博客
01-20 2901
flatMap算子和map有些相似，输入都是数据流中的每个元素，与之不同的是，flatMap的输出可以是零个、一个或多个元素，它的输出元素放在了Collector类对象中，接下来我们进入到代码中来进行分析，我们使用示例如下： // 计算数据 DataStream<WordWithCount> windowCount = text.flatMap(new FlatMapFunctio...
【Flink1.14实战】Flink DataStream 算子 Map
一片冰心
04-08 628
Map DataStream → DataStream 接受一个元素并产生一个元素。将输入流的值加倍的映射函数： package quick; import org.apache.flink.api.common.functions.MapFunction; import org.apache.flink.streaming.api.datastream.DataStream; import org.apache.flink.streaming.api.environment.StreamExecuti
【Flink1.14实战】Flink DataStream 算子 FlatMap
一片冰心
04-08 1451
FlatMap DataStream → DataStream 接受一个元素并产生零个、一个或多个元素。将句子拆分为单词的 flatmap 函数： package quick; import org.apache.flink.api.common.functions.FlatMapFunction; import org.apache.flink.streaming.api.datastream.DataStream; import org.apache.flink.streaming.api.envir
【flink源码-1】【DataStream API】datastream程序各部分的作用、pipeline构建的意义、flink算子的内部结构有哪些之map源码分析
hiliang521的博客
01-05 370
【flink源码-1】【DataStream API】datastream的程序结构、map源码逻辑、flink pipeline构建逻辑
Flink DataStream API 介绍
技术大神之路
06-03 316
DataStream 编程模型 DataSource模块负责数据接入 内置数据源：文件数据源readTextFile/readFile(InputFormat)，Socket端口socketTextStream，集合数据源 fromElements 第三方数据源: 仅支持读取：Netty 仅支持输出：ElasticSearch，HDFS 支持读取和输出：Kafaka，RabbitMQ 用户自定义数据源连接器 Transformation模块负责数据集的各种转换操作 单SingleDataSt
如何使用 DataStream API 来处理数据？
http://www.54tianzhisheng.cn/
09-22 608
在 3.3 节中讲了数据转换常用的 Operators（算子），然后在 3.2 节中也讲了 Flink 中窗口的概念和原理，那么我们这篇文章再来细讲一下 Flink 中的各种 DataStream API。 我们先来看下源码里面的 DataStream 大概有哪些类呢？ 可以发现其实还是有很多的类，只有熟练掌握了这些 API，我们才能在做数据转换和计算的时候足够灵活的运用开来（知道何时该选用哪种...
Flink流计算之聚合函数
踏雪无痕
08-07 4108
一.Reduce功能 ReduceFunction指定如何将输入中的两个元素组合在一起以产生相同类型的输出元素。Flink使用ReduceFunction来逐步聚合窗口的元素。 ReduceFunction可以定义像这样使用： val input: DataStream[(String, Long)] = ... input .keyBy(<key selector>) .window(<window assigner>) .reduce { (v1, v2
Flink DataStream之使用filter实现分流
QYHuiiQ
07-09 848
可以看到输入的"World"由于不满足两个filter中的任何一个，所以数据被舍弃。"Monday"和"World"分别打印在两个不同的流中。
Flink核心API之DataStream
libaowenBlog的博客
08-20 342
两个流被connect之后，只是被放到了同一个流中，它们内部依然保持各自的数据和形式不发生任何变 化，两个流相互独立。connect方法会返回connectedStream，在connectedStream中需要使用CoMap、CoFlatMap这种函 数，类似于map和flatmap。split切分的流无法进行二次切分，并且split方法已经标记为过时了，官方不推荐使用，现在官方推荐 使用side output的方式实现。
flink 基础知识梳理（DataSet、DataStream、map、filter、filterMap）
anita9999的博客
11-18 1003
1.DataSet和DataStream的区别 DataSet:有界数据流，数据批处理；处理完一条数据，把它放到缓存里，当缓存空间写满时，把它映射到磁盘上；在所有数据处理完之后，才将其通过网络传输到下一个节点，要求高通吐。 DataStream无界数据流，数据流处理；处理完一条数据，把它序列到缓存，并将其通过网络传输到一下个节点进行处理，要求低延迟。 2.map、filter、filterMap的区别 map:数据流经过map算子处理之后，再流出；它是有多少数据，处理完之后就流出多少数据 filt
Flink学习9---DataStream之功能更丰富的Transformation算子RichMapFunction
zhuzuwei的博客
07-05 1998
Flink还提供了功能更丰富的Transformation实现接口。 RichFuction除了提供原来MapFuction的方法之外，还提供open, close, getRuntimeContext 和setRuntimeContext方法，这些功能可用于参数化函数（传递参数），创建和完成本地状态，访问广播变量以及访问运行时信息以及有关迭代中的信息。 import org.apache.flink.api.common.functions.FilterFunction; import org.
【Flink1.14实战】Flink DataStream 算子快速开始 Filter
一片冰心
04-09 1236
Filter DataStream → DataStream 过滤流。过滤掉零值的过滤器 package quick; import org.apache.flink.api.common.functions.FilterFunction; import org.apache.flink.streaming.api.datastream.DataStream; import org.apache.flink.streaming.api.environment.StreamExecutionEnvironm
java-Stream原理及相关操作详解(filter、map、flatMap、peek、reduce、anyMatch等等)
最新发布
supermanman_的博客
04-05 2736
Stream流本质上是一个执行计算的过程，将流当中的中间操作组成一个流管道的形式，流管道由源（可能是数组，集合，生成器函数，I / O通道等），零个或多个中间操作 （将流转换为另一个流，如filter(Predicate) ）组成，以及终端操作 （产生结果或副作用，例如count()、forEach(Consumer) 、collect(?
flink常用算子介绍
运维仙人
02-27 494
flink任务中【Transformation 数据转换】是对数据进行操作，有 Map、FlatMap、Filter、KeyBy 、Reduce 、Fold 、Aggregations、Window 、WindowAll 、Union 、Window join 、Split 、Select 、Project 等，通过对数据的操作，转换成想要的数据，即是目标数据。KeyBy 在逻辑上是基于 key 对流进⾏分区，相同的 Key 会被分到⼀个分区（这⾥分区指的就是下游算⼦多个并⾏节点的其中⼀个）。
Flink 系例 之 Map
不会飞的小龙人的博客
09-14 758
Map算子：对数据流一对一的加载计算，并返回一个新的对象 示例环境 java.version: 1.8.x flink.version: 1.11.1 示例数据源 Flink 系例 之 搭建开发环境与数据 Map.java import com.flink.demo.DataSource; import org.apache.flink.api.common.functions.MapFunction; import org.apache.flink.api.java.tuple.Tup.
「Flink实时数据分析系列」5. Flink的DataStream API（v1.7）
大数据与人工智能
03-12 671
来源 |「Stream Processing with Apache Flink」作者|Fabian Hueske and Vasiliki Kalavri翻译|吴邪大数据4年...
flink中reduce/aggregate/fold/apply
09-22
### 回答1： 这些都是 Flink 中的数据转换操作，它们可以对数据流进行聚合、合并、转换等操作。其中 reduce 和 fold 都是对数据流中的元素进行聚合操作，不同之处在于 reduce 是基于两个元素进行聚合，而 fold 是基于一个初始值和一个元素进行聚合。Aggregate 则是对数据流中的元素进行合并操作，可以使用预定义的聚合函数或自定义聚合函数。Apply 则是对数据流中的每个元素进行转换操作，可以使用预定义的函数或自定义函数。 ### 回答2： Flink是一个分布式大数据处理框架，提供了多种操作函数来对数据进行处理。其中reduce、aggregate、fold和apply都是常用的操作函数。 1. Reduce函数（缩减函数）：reduce函数用于将输入的多个元素进行聚合操作，返回一个单一的结果。它是一个折叠操作，将每个输入元素依次传递给聚合函数，产生一个累积的结果。这个函数通常用于对数据流中的元素进行求和、求平均、求最大值等简单的聚合操作。 2. Aggregate函数（累计函数）：aggregate函数与reduce函数类似，也是用于将输入的多个元素进行聚合操作。不同之处在于，aggregate函数可以接收一个初始值，对输入元素进行累加操作，并将结果返回。通常情况下，aggregate函数用于实现更加复杂的聚合操作，例如计算每个窗口的平均值、最大值等。 3. Fold函数（折叠函数）：fold函数是reduce函数的一种特殊形式，它将输入的元素进行聚合操作，并返回一个和输入元素类型相同的结果。与reduce函数不同的是，fold函数接收一个初始值，将其作为第一个输入元素，然后依次将输入元素进行折叠操作，最终返回结果。通常情况下，fold函数用于将数据流中的元素进行聚合，并返回一个新的结果。 4. Apply函数（应用函数）：apply函数是一个通用的操作函数，它可以接收任意的输入和输出类型，并对数据进行处理。apply函数通常用于实现自定义的数据转换、筛选或其他复杂的处理逻辑。我们可以在apply函数中编写自己的业务逻辑，对数据流进行任意的处理操作。 总而言之，reduce、aggregate、fold和apply函数都是用于对Flink数据流进行处理和聚合的常用操作函数，它们在不同的场景下有不同的应用和效果。 ### 回答3： Flink是一个用于大规模流数据处理和批处理的流行开源框架。在Flink中，reduce、aggregate、fold和apply是用于数据处理的操作函数。 1. Reduce（规约）：Reduce函数用于合并流数据集中的元素，将多个元素聚合成一个元素。Reduce操作将应用到每个流数据集的每个元素上，并将结果进行合并，返回一个新的流数据集。例如，可以使用Reduce函数来计算流数据集中的元素的总和或最大值。 2. Aggregate（聚合）：Aggregate函数类似于Reduce函数，但是它可以进行更复杂的聚合操作。Aggregate操作将一个输入数据集聚合为一个或多个结果，并可以带有中间状态。它可以用于实现统计操作，例如计算平均值或中位数。 3. Fold（折叠）：Fold函数与Reduce函数类似，它也是将多个元素聚合成一个元素。但是与Reduce函数不同的是，Fold函数可以指定一个初始值，并对每个元素应用聚合操作。Fold函数将应用到每个流数据集的每个元素上，并将结果进行合并，返回一个新的流数据集。例如，可以使用Fold函数来计算流数据集中元素的累加和。 4. Apply（应用）：Apply函数用于在流数据集上应用用户自定义的函数。它可以接受一个或多个输入流数据集，并生成一个或多个输出流数据集。Apply函数在流数据集上执行指定的用户定义的操作，可以是映射、过滤、转换等。通过Apply函数，用户可以根据自己的需求对流数据进行灵活的处理和操作。 总结：flink中的reduce、aggregate、fold和apply是用于对流数据集进行处理和操作的函数。它们分别用于合并、聚合、折叠和应用操作，可以帮助用户实现各种数据处理需求。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值