点一下关注吧！！！非常感谢！！持续更新！！！
目前已经更新到了：
Hadoop（已更完）
HDFS（已更完）
MapReduce（已更完）
Hive（已更完）
Flume（已更完）
Sqoop（已更完）
Zookeeper（已更完）
HBase（已更完）
Redis （已更完）
Kafka（已更完）
Spark（已更完）
Flink（正在更新！）
章节内容
上节我们完成了如下的内容：
Flink DataStream API
Rich并行源 并行源
Flink针对DataStream提供了大量的已经实现的算子
Map
DataStream -> DataStream，获取一个元素并产生一个元素。
以下是将输入流中的值*2的映射函数：
DataStream<Integer> dataStream = //... dataStream.map(new MapFunction<Integer, Integer>() { @Override public Integer map(Integer value) throws Exception { return 2 * value; } });
FlatMap
DataStream -> DataStream
获取一个元素，产生0个、1个、多个元素。
以下是一个FlapMap函数切分句子：
dataStream.flatMap(new FlatMapFunction<String, String>() { @Override public void flatMap(String value, Collector<String> out) throws Exception { for(String word: value.split(" ")){ out.collect(word); } } });
Filter
DataSteam -> DataStream
返回一个布尔值，如果满足条件就筛选出来。
以下是去掉0的值：
dataStream.filter(new FilterFunction<Integer>() { @Override public boolean filter(Integer value) throws Exception { return value != 0; } });
KeyBy
DataStream -> KeyedStream
将流逻辑上划分为不相交的分区。所有具有相同键的记录被分配到相同的分区。在函数的内部，keyBy() 使用哈希分区实现。
有不同的方法来指定键。 此转换返回一个 KeyedStream。
dataStream.keyBy(value -> value.getSomeKey()) dataStream.keyBy(value -> value.f0)
Reduce
KeyedStream -> DataStream
"滚动"归约是一种在数据流处理中常用的操作。简单来说，它是一个累积的过程，逐个处理流中的元素并将结果逐步更新。
键控数据流：这是指数据流中的元素根据某个键（如ID或类别）进行分组。
当前元素：这是指数据流中正在处理的当前记录。
上一个归约值：这是指之前已经处理过并累积的结果。
keyedStream.reduce(new ReduceFunction<Integer>() { @Override public Integer reduce(Integer value1, Integer value2) throws Exception { return value1 + value2; } });
举一个例子：
部分和是一种典型的归约操作，它逐步计算出流中各元素的累积和。例如，对于一个输入数据流 [1, 2, 3, 4, 5]，部分和的输出将是 [1, 3, 6, 10, 15]。也就是说：
第一个元素1的部分和是1。
第二个元素2的部分和是1+2=3。
第三个元素3的部分和是1+2+3=6。
以此类推。
通过这样的处理方式，你可以在数据流中实时地看到每一步累积的结果。
Fold
KeyedStream -> DataStream
对于带有初始值的键控数据流进行滚动折叠，将当前元素与上一个折叠值相互结合，并发出新值。
一个折叠函数，应用序列是：（1,2,3,4,5），会发出：start-1、start-1-2、start-1-2-3…
DataStream<String> result = keyedStream.fold("start", new FoldFunction<Integer, String>() { @Override public String fold(String current, Integer value) { return current + "-" + value; } });
Aggregations
KeyedStream -> DataStream
对KeyedStream进行滚动聚合，min 和 minBy 的区别在于，min 返回最小值，而 minBy 返回该字段中具有最小元素值（max 和 maxBy 同理）。
keyedStream.sum(0); keyedStream.sum("key"); keyedStream.min(0); keyedStream.min("key"); keyedStream.max(0); keyedStream.max("key"); keyedStream.minBy(0); keyedStream.minBy("key"); keyedStream.maxBy(0); keyedStream.maxBy("key");
Window
KeyedStream -> WindowedStream
可以在已经分区的KeyedStream上定义窗口，窗口根据某些特性（例如：最近5秒内到达的数据），对每个键中的数据进行分组。
// Last 5 seconds of data dataStream.keyBy(value -> value.f0).window(TumblingEventTimeWindows.of(Time.seconds(5)));
WindowAll
DataStream -> AllWindowStream
可以在常规的 DataStream 上定义窗口，窗口根据某些特性（例如：最近5秒内到达的数据）对所有流事件进行分组。
// Last 5 seconds of data dataStream.windowAll(TumblingEventTimeWindows.of(Time.seconds(5)));
Window Apply
WindowedStream -> DataStream
AllWindowedStream -> DataStream
对整个窗口应用一个通用函数：
windowedStream.apply (new WindowFunction<Tuple2<String,Integer>, Integer, Tuple, Window>() { public void apply (Tuple tuple, Window window, Iterable<Tuple2<String, Integer>> values, Collector<Integer> out) throws Exception { int sum = 0; for (value t: values) { sum += t.f1; } out.collect (new Integer(sum)); } }); // applying an AllWindowFunction on non-keyed window stream allWindowedStream.apply (new AllWindowFunction<Tuple2<String,Integer>, Integer, Window>() { public void apply (Window window, Iterable<Tuple2<String, Integer>> values, Collector<Integer> out) throws Exception { int sum = 0; for (value t: values) { sum += t.f1; } out.collect (new Integer(sum)); } });
Window Reduce
WindowedStream -> DataStream
对于一个功能性Reduce函数应用于窗口，并返回简化的值。
windowedStream.reduce (new ReduceFunction<Tuple2<String,Integer>>() { public Tuple2<String, Integer> reduce(Tuple2<String, Integer> value1, Tuple2<String, Integer> value2) throws Exception { return new Tuple2<String,Integer>(value1.f0, value1.f1 + value2.f1); } });
Window Fold
WindowedStream -> DataStream
应用一个函数式的折叠函数到窗口，并返回折叠后的值。
示例函数在序列（1,2,3,4,5）上应用时，将折叠成字符：start-1-2-3-4-5
windowedStream.fold("start", new FoldFunction<Integer, String>() { public String fold(String current, Integer value) { return current + "-" + value; } });
Aggregations on windows
WindowedStream -> DataStream
聚合窗口中的内容，min 和 minBy 的区别于，min 返回最小值，而 minBy 返回在此字段中具有最小值的元素（max 和 maxBy 同理）
windowedStream.sum(0); windowedStream.sum("key"); windowedStream.min(0); windowedStream.min("key"); windowedStream.max(0); windowedStream.max("key"); windowedStream.minBy(0); windowedStream.minBy("key"); windowedStream.maxBy(0); windowedStream.maxBy("key");
Union
DataStream -> DataStream
将两个或者多个数据流合并，创建一个包含所有数据流中所有元素的新数据流。
注意：如果一个数据流于自身合并，结果数据流中每个元素将出现两次。
dataStream.union(otherStream1, otherStream2, ...);
Window Join
DataStream, DataStream -> DataStream
将两个数据流按给定的键和一个公共窗口进行连接。
dataStream .join(otherStream) .where(<key selector>).equalTo(<key selector>) .window(TumblingEventTimeWindows.of(Time.seconds(3))) .apply (new JoinFunction () {...});
Interval Join
KeyedStream, KeyedStream -> DataStream
将两个具有相同键的键控流中的元素e1和e2在给定时间间隔内连接起来，使得e2的时间戳满足 e1.timestamp + lowerBound <= e2.timestamp <= e1.timestamp + upperBound
// this will join the two streams so that // key1 == key2 && leftTs - 2 < rightTs < leftTs + 2 keyedStream.intervalJoin(otherKeyedStream) .between(Time.milliseconds(-2), Time.milliseconds(2)) // lower and upper bound .upperBoundExclusive(true) // optional .lowerBoundExclusive(true) // optional .process(new IntervalJoinFunction() {...});
Window CoGroup
DataStream, DataStream -> DataStream
将两个数据流在给定键和公共窗口上进行合并。
dataStream.coGroup(otherStream) .where(0).equalTo(1) .window(TumblingEventTimeWindows.of(Time.seconds(3))) .apply (new CoGroupFunction () {...});
Connect
DataStrean, DataStream -> ConnectedStreams
将两个数据流连接起来，保留他们的类型，连接允许在两个数据流之间共享。
DataStream<Integer> someStream = //... DataStream<String> otherStream = //... ConnectedStreams<Integer, String> connectedStreams = someStream.connect(otherStream);
CoMap, CoFlatMap
ConnetedStreams -> DataStream
类似Map和FlatMap，只不过是连接流。
connectedStreams.map(new CoMapFunction<Integer, String, Boolean>() { @Override public Boolean map1(Integer value) { return true; } @Override public Boolean map2(String value) { return false; } }); connectedStreams.flatMap(new CoFlatMapFunction<Integer, String, String>() { @Override public void flatMap1(Integer value, Collector<String> out) { out.collect(value.toString()); } @Override public void flatMap2(String value, Collector<String> out) { for (String word: value.split(" ")) { out.collect(word); } } });
