# Flink Java API接口介绍
由于Flink开源版本升级，为避免出现API兼容性或可靠性问题，建议用户使用配套版本的API。
#### Flink常用接口
Flink主要使用到如下这几个类：
- StreamExecutionEnvironment：是Flink流处理的基础，提供了程序的执行环境。
- DataStream：Flink用类DataStream来表示程序中的流式数据。用户可以认为它们是含有重复数据的不可修改的集合(collection)，DataStream中元素的数量是无限的。
- KeyedStream：DataStream通过keyBy分组操作生成流，通过设置的key值对数据进行分组。
- WindowedStream：KeyedStream通过window窗口函数生成的流，设置窗口类型并且定义窗口触发条件，然后在窗口数据上进行一些操作。
- AllWindowedStream：DataStream通过window窗口函数生成的流，设置窗口类型并且定义窗口触发条件，然后在窗口数据上进行一些操作。
- ConnectedStreams：将两条DataStream流连接起来并且保持原有流数据的类型，然后进行map或者flatMap操作。
- JoinedStreams：在窗口上对数据进行等值join操作（等值就是判断两个值相同的join，比如a.id = b.id），join操作是coGroup操作的一种特殊场景。
- CoGroupedStreams：在窗口上对数据进行coGroup操作，可以实现流的各种join类型。
图1Flink Stream的各种流类型转换   
![](https://support.huaweicloud.com/devg-lts-mrs/zh-cn_image_0000001252692806.png "点击放大")
#### 流数据输入
表1流数据输入的相关接口 
| **API**                                                                                                                                                                                   | **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|:---|:---|
| public final \<OUT\> DataStreamSource\<OUT\> fromElements(OUT... data)                                                                                                                    | 获取用户定义的多个元素的数据，作为输入流数据。 - type为元素的数据类型。  - data为多个元素的具体数据。                                                                                                                                                                                                                                                                                                                       |
| public final \<OUT\> DataStreamSource\<OUT\> fromElements(Class\<OUT\> type, OUT... data)                                                                                                 | 获取用户定义的多个元素的数据，作为输入流数据。 - type为元素的数据类型。  - data为多个元素的具体数据。                                                                                                                                                                                                                                                                                                                       |
| public \<OUT\> DataStreamSource\<OUT\> fromCollection(Collection\<OUT\> data)                                                                                                             | 获取用户定义的集合数据，作为输入流数据。 - type为集合中元素的数据类型。  - typeInfo为集合中根据元素数据类型获取的类型信息。  - data为集合数据或者可迭代的数据体。                                                                                                                                                                             |
| public \<OUT\> DataStreamSource\<OUT\> fromCollection(Collection\<OUT\> data, TypeInformation\<OUT\> typeInfo)                                                                            | 获取用户定义的集合数据，作为输入流数据。 - type为集合中元素的数据类型。  - typeInfo为集合中根据元素数据类型获取的类型信息。  - data为集合数据或者可迭代的数据体。                                                                                                                                                                             |
| public \<OUT\> DataStreamSource\<OUT\> fromCollection(Iterator\<OUT\> data, Class\<OUT\> type)                                                                                            | 获取用户定义的集合数据，作为输入流数据。 - type为集合中元素的数据类型。  - typeInfo为集合中根据元素数据类型获取的类型信息。  - data为集合数据或者可迭代的数据体。                                                                                                                                                                             |
| public \<OUT\> DataStreamSource\<OUT\> fromCollection(Iterator\<OUT\> data, TypeInformation\<OUT\> typeInfo)                                                                              | 获取用户定义的集合数据，作为输入流数据。 - type为集合中元素的数据类型。  - typeInfo为集合中根据元素数据类型获取的类型信息。  - data为集合数据或者可迭代的数据体。                                                                                                                                                                             |
| public \<OUT\> DataStreamSource\<OUT\> fromParallelCollection(SplittableIterator\<OUT\> iterator, Class\<OUT\> type)                                                                      | 获取用户定义的集合数据，作为输入并行流数据。 - type为集合中元素的数据类型。  - typeInfo为集合中根据元素数据类型获取的类型信息。  - iterator为可被分割成多个partition的迭代数据体。                                                                                                                                                              |
| public \<OUT\> DataStreamSource\<OUT\> fromParallelCollection(SplittableIterator\<OUT\> iterator, TypeInformation\<OUT\> typeInfo)                                                        | 获取用户定义的集合数据，作为输入并行流数据。 - type为集合中元素的数据类型。  - typeInfo为集合中根据元素数据类型获取的类型信息。  - iterator为可被分割成多个partition的迭代数据体。                                                                                                                                                              |
| private \<OUT\> DataStreamSource\<OUT\> fromParallelCollection(SplittableIterator\<OUT\> iterator, TypeInformation\<OUT\> typeInfo, String operatorName)                                  | 获取用户定义的集合数据，作为输入并行流数据。 - type为集合中元素的数据类型。  - typeInfo为集合中根据元素数据类型获取的类型信息。  - iterator为可被分割成多个partition的迭代数据体。                                                                                                                                                              |
| public DataStreamSource\<Long\> generateSequence(long from, long to)                                                                                                                      | 获取用户定义的一串序列数据，作为输入流数据。 - from是指数值串的起点。  - to是指数值串的终点。                                                                                                                                                                                                                                                                                                                            |
| public DataStreamSource\<String\> readTextFile(String filePath)                                                                                                                           | 获取用户定义的某路径下的文本文件数据，作为输入流数据。 - filePath是指文本文件的路径。  - charsetName是编码格式的名字。                                                                                                                                                                                                                                                                                                         |
| public DataStreamSource\<String\> readTextFile(String filePath, String charsetName)                                                                                                       | 获取用户定义的某路径下的文本文件数据，作为输入流数据。 - filePath是指文本文件的路径。  - charsetName是编码格式的名字。                                                                                                                                                                                                                                                                                                         |
| public \<OUT\> DataStreamSource\<OUT\> readFile(FileInputFormat\<OUT\> inputFormat, String filePath)                                                                                      | 获取用户定义的某路径下的文件数据，作为输入流数据。 - filePath是指文件的路径。  - inputFormat是指文件的格式。  - watchType指的是文件的处理模式"PROCESS_ONCE"或者"PROCESS_CONTINUOUSLY"。  - interval指的是多长时间判断目录或文件变化进行处理。   |
| public \<OUT\> DataStreamSource\<OUT\> readFile(FileInputFormat\<OUT\> inputFormat, String filePath, FileProcessingMode watchType, long interval)                                         | 获取用户定义的某路径下的文件数据，作为输入流数据。 - filePath是指文件的路径。  - inputFormat是指文件的格式。  - watchType指的是文件的处理模式"PROCESS_ONCE"或者"PROCESS_CONTINUOUSLY"。  - interval指的是多长时间判断目录或文件变化进行处理。   |
| public \<OUT\> DataStreamSource\<OUT\> readFile(FileInputFormat\<OUT\> inputFormat, String filePath, FileProcessingMode watchType, long interval, TypeInformation\<OUT\> typeInformation) | 获取用户定义的某路径下的文件数据，作为输入流数据。 - filePath是指文件的路径。  - inputFormat是指文件的格式。  - watchType指的是文件的处理模式"PROCESS_ONCE"或者"PROCESS_CONTINUOUSLY"。  - interval指的是多长时间判断目录或文件变化进行处理。   |
| public DataStreamSource\<String\> socketTextStream(String hostname, int port, String delimiter, long maxRetry)                                                                            | 获取用户定义的Socket数据，作为输入流数据。 - hostname是指Socket的服务器端的主机名称。  - port指的是服务器的监测端口。  - delimiter指的是消息之间的分隔符。  - maxRetry指的是由于连接异常可以触发的最大重试次数。                                 |
| public DataStreamSource\<String\> socketTextStream(String hostname, int port, String delimiter)                                                                                           | 获取用户定义的Socket数据，作为输入流数据。 - hostname是指Socket的服务器端的主机名称。  - port指的是服务器的监测端口。  - delimiter指的是消息之间的分隔符。  - maxRetry指的是由于连接异常可以触发的最大重试次数。                                 |
| public DataStreamSource\<String\> socketTextStream(String hostname, int port)                                                                                                             | 获取用户定义的Socket数据，作为输入流数据。 - hostname是指Socket的服务器端的主机名称。  - port指的是服务器的监测端口。  - delimiter指的是消息之间的分隔符。  - maxRetry指的是由于连接异常可以触发的最大重试次数。                                 |
| public \<OUT\> DataStreamSource\<OUT\> addSource(SourceFunction\<OUT\> function)                                                                                                          | 用户自定义SourceFunction，addSource方法可以添加Kafka等数据源，主要实现方法为SourceFunction的run。 - function指的是用户自定义的SourceFunction函数。  - sourceName指的是定义该数据源的名称。  - typeInfo则是根据元素数据类型获取的类型信息。                                                                                                      |
| public \<OUT\> DataStreamSource\<OUT\> addSource(SourceFunction\<OUT\> function, String sourceName)                                                                                       | 用户自定义SourceFunction，addSource方法可以添加Kafka等数据源，主要实现方法为SourceFunction的run。 - function指的是用户自定义的SourceFunction函数。  - sourceName指的是定义该数据源的名称。  - typeInfo则是根据元素数据类型获取的类型信息。                                                                                                      |
| public \<OUT\> DataStreamSource\<OUT\> addSource(SourceFunction\<OUT\> function, TypeInformation\<OUT\> typeInfo)                                                                         | 用户自定义SourceFunction，addSource方法可以添加Kafka等数据源，主要实现方法为SourceFunction的run。 - function指的是用户自定义的SourceFunction函数。  - sourceName指的是定义该数据源的名称。  - typeInfo则是根据元素数据类型获取的类型信息。                                                                                                      |
| public \<OUT\> DataStreamSource\<OUT\> addSource(SourceFunction\<OUT\> function, String sourceName, TypeInformation\<OUT\> typeInfo)                                                      | 用户自定义SourceFunction，addSource方法可以添加Kafka等数据源，主要实现方法为SourceFunction的run。 - function指的是用户自定义的SourceFunction函数。  - sourceName指的是定义该数据源的名称。  - typeInfo则是根据元素数据类型获取的类型信息。                                                                                                      |
   
#### 数据输出
表2数据输出的相关接口 
| **API**                                                                                                                                 | **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
|:---|:---|
| public DataStreamSink\<T\> print()                                                                                                      | 数据输出以标准输出流打印出来。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| public DataStreamSink\<T\> printToErr()                                                                                                 | 数据输出以标准error输出流打印出来。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| public DataStreamSink\<T\> writeAsText(String path)                                                                                     | 数据输出写入到某个文本文件中。 - path指的是文本文件的路径。  - writeMode为文本文件写入模式"OVERWRITE"或者"NO_OVERWRITE"。                                                                                                                                                                                                                                                                 |
| public DataStreamSink\<T\> writeAsText(String path, WriteMode writeMode)                                                                | 数据输出写入到某个文本文件中。 - path指的是文本文件的路径。  - writeMode为文本文件写入模式"OVERWRITE"或者"NO_OVERWRITE"。                                                                                                                                                                                                                                                                 |
| public DataStreamSink\<T\> writeAsCsv(String path)                                                                                      | 数据输出写入到某个csv格式的文件中。 - path指的是文本文件的路径。  - writeMode为文本文件写入模式"OVERWRITE"或者"NO_OVERWRITE"。  - rowDelimiter为行分隔符。  - fieldDelimiter为列分隔符。   |
| public DataStreamSink\<T\> writeAsCsv(String path, WriteMode writeMode)                                                                 | 数据输出写入到某个csv格式的文件中。 - path指的是文本文件的路径。  - writeMode为文本文件写入模式"OVERWRITE"或者"NO_OVERWRITE"。  - rowDelimiter为行分隔符。  - fieldDelimiter为列分隔符。   |
| public \<X extends Tuple\> DataStreamSink\<T\> writeAsCsv(String path, WriteMode writeMode, String rowDelimiter, String fieldDelimiter) | 数据输出写入到某个csv格式的文件中。 - path指的是文本文件的路径。  - writeMode为文本文件写入模式"OVERWRITE"或者"NO_OVERWRITE"。  - rowDelimiter为行分隔符。  - fieldDelimiter为列分隔符。   |
| public DataStreamSink\<T\> writeToSocket(String hostName, int port, SerializationSchema\<T\> schema)                                    | 数据输出写入到Socket连接中。 - hostName为主机名称。  - port为端口。                                                                                                                                                                                                                                                                                                      |
| public DataStreamSink\<T\> writeUsingOutputFormat(OutputFormat\<T\> format)                                                             | 数据输出到普通文件中，例如二进制文件。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| public DataStreamSink\<T\> addSink(SinkFunction\<T\> sinkFunction)                                                                      | 用户自定义的数据输出，addSink方法可以添加Kafka等数据输出，主要实现方法为SinkFunction的invoke方法。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
   
#### 过滤和映射能力
表3过滤和映射能力的相关接口 
| **API**                                                                                  | **说明**                      |
|:---|:---|
| public \<R\> SingleOutputStreamOperator\<R\> map(MapFunction\<T, R\> mapper)             | 输入一个元素，生成另一个元素，元素类型不变。      |
| public \<R\> SingleOutputStreamOperator\<R\> flatMap(FlatMapFunction\<T, R\> flatMapper) | 输入一个元素，生成零个、一个或者多个元素。       |
| public SingleOutputStreamOperator\<T\> filter(FilterFunction\<T\> filter)                | 对每个元素执行一个布尔函数，只保留返回true的元素。 |
   
#### 聚合能力
表4聚合能力的相关接口 
| **API**                                                                                        | **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|:---|:---|
| public KeyedStream\<T, Tuple\> keyBy(int... fields)                                            | 将流逻辑分区成不相交的分区，每个分区包含相同key的元素。内部是用hash分区来实现的。这个转换返回了一个KeyedStream。 KeyBy操作之后返回KeyedStream，然后再调用KeyedStream的函数（例如reduce/fold/min/minby/max/maxby/sum/sumby等）进行相应操作。 - fields为数据某几列的序号或者成员变量的名称。  - key则为用户自定义的指定分区依据的方法。   |
| public KeyedStream\<T, Tuple\> keyBy(String... fields)                                         | 将流逻辑分区成不相交的分区，每个分区包含相同key的元素。内部是用hash分区来实现的。这个转换返回了一个KeyedStream。 KeyBy操作之后返回KeyedStream，然后再调用KeyedStream的函数（例如reduce/fold/min/minby/max/maxby/sum/sumby等）进行相应操作。 - fields为数据某几列的序号或者成员变量的名称。  - key则为用户自定义的指定分区依据的方法。   |
| public \<K\> KeyedStream\<T, K\> keyBy(KeySelector\<T, K\> key)                                | 将流逻辑分区成不相交的分区，每个分区包含相同key的元素。内部是用hash分区来实现的。这个转换返回了一个KeyedStream。 KeyBy操作之后返回KeyedStream，然后再调用KeyedStream的函数（例如reduce/fold/min/minby/max/maxby/sum/sumby等）进行相应操作。 - fields为数据某几列的序号或者成员变量的名称。  - key则为用户自定义的指定分区依据的方法。   |
| public SingleOutputStreamOperator\<T\> reduce(ReduceFunction\<T\> reducer)                     | 在一个KeyedStream上"滚动"reduce。合并当前元素与上一个被reduce的值，然后输出新的值。注意三者的类型是一致的。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| public \<R\> SingleOutputStreamOperator\<R\> fold(R initialValue, FoldFunction\<T, R\> folder) | 在一个KeyedStream上基于一个初始值"滚动"折叠。合并当前元素和上一个被折叠的值，然后输出新值。注意Fold的输入值与返回值类型可以不一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| public SingleOutputStreamOperator\<T\> sum(int positionToSum)                                  | 在一个KeyedStream上滚动求和操作。 positionToSum和field代表对某一列求和。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| public SingleOutputStreamOperator\<T\> sum(String field)                                       | 在一个KeyedStream上滚动求和操作。 positionToSum和field代表对某一列求和。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| public SingleOutputStreamOperator\<T\> min(int positionToMin)                                  | 在一个KeyedStream上滚动求最小值。min返回了最小值，不保证非最小值列的准确性。 positionToMin和field代表对某一列求最小值。                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| public SingleOutputStreamOperator\<T\> min(String field)                                       | 在一个KeyedStream上滚动求最小值。min返回了最小值，不保证非最小值列的准确性。 positionToMin和field代表对某一列求最小值。                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| public SingleOutputStreamOperator\<T\> max(int positionToMax)                                  | 在一个KeyedStream上滚动求最大值。max返回了最大值，不保证非最大值列的准确性。 positionToMax和field代表对某一列求最大值。                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| public SingleOutputStreamOperator\<T\> max(String field)                                       | 在一个KeyedStream上滚动求最大值。max返回了最大值，不保证非最大值列的准确性。 positionToMax和field代表对某一列求最大值。                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| public SingleOutputStreamOperator\<T\> minBy(int positionToMinBy)                              | 在一个KeyedStream上求某一列最小值所在的该行数据，minBy返回了该行数据的所有元素。 - positionToMinBy代表对哪一列做minBy操作。  - first表示是否按最先遇到的最小值输出还是最后遇到的最小值输出。                                                                                                                                                      |
| public SingleOutputStreamOperator\<T\> minBy(String positionToMinBy)                           | 在一个KeyedStream上求某一列最小值所在的该行数据，minBy返回了该行数据的所有元素。 - positionToMinBy代表对哪一列做minBy操作。  - first表示是否按最先遇到的最小值输出还是最后遇到的最小值输出。                                                                                                                                                      |
| public SingleOutputStreamOperator\<T\> minBy(int positionToMinBy, boolean first)               | 在一个KeyedStream上求某一列最小值所在的该行数据，minBy返回了该行数据的所有元素。 - positionToMinBy代表对哪一列做minBy操作。  - first表示是否按最先遇到的最小值输出还是最后遇到的最小值输出。                                                                                                                                                      |
| public SingleOutputStreamOperator\<T\> minBy(String field, boolean first)                      | 在一个KeyedStream上求某一列最小值所在的该行数据，minBy返回了该行数据的所有元素。 - positionToMinBy代表对哪一列做minBy操作。  - first表示是否按最先遇到的最小值输出还是最后遇到的最小值输出。                                                                                                                                                      |
| public SingleOutputStreamOperator\<T\> maxBy(int positionToMaxBy)                              | 在一个KeyedStream上求某一列最大值所在的该行数据，maxBy返回了该行数据的所有元素。 - positionToMaxBy代表对哪一列做maxBy操作。  - first表示是否按最先遇到的最大值输出还是最后遇到的最大值输出。                                                                                                                                                      |
| public SingleOutputStreamOperator\<T\> maxBy(String positionToMaxBy)                           | 在一个KeyedStream上求某一列最大值所在的该行数据，maxBy返回了该行数据的所有元素。 - positionToMaxBy代表对哪一列做maxBy操作。  - first表示是否按最先遇到的最大值输出还是最后遇到的最大值输出。                                                                                                                                                      |
| public SingleOutputStreamOperator\<T\> maxBy(int positionToMaxBy, boolean first)               | 在一个KeyedStream上求某一列最大值所在的该行数据，maxBy返回了该行数据的所有元素。 - positionToMaxBy代表对哪一列做maxBy操作。  - first表示是否按最先遇到的最大值输出还是最后遇到的最大值输出。                                                                                                                                                      |
| public SingleOutputStreamOperator\<T\> maxBy(String field, boolean first)                      | 在一个KeyedStream上求某一列最大值所在的该行数据，maxBy返回了该行数据的所有元素。 - positionToMaxBy代表对哪一列做maxBy操作。  - first表示是否按最先遇到的最大值输出还是最后遇到的最大值输出。                                                                                                                                                      |
   
#### 数据流分发能力
表5数据流分发能力的相关接口 
| **API**                                                                                                     | **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|:---|:---|
| public \<K\> DataStream\<T\> partitionCustom(Partitioner\<K\> partitioner, int field)                       | 使用一个用户自定义的Partitioner对每一个元素选择目标task。 - partitioner指的是用户自定义的分区类重写partition方法。  - field指的是partitioner的输入参数。  - keySelector指的是用户自定义的partitioner的输入参数。   |
| public \<K\> DataStream\<T\> partitionCustom(Partitioner\<K\> partitioner, String field)                    | 使用一个用户自定义的Partitioner对每一个元素选择目标task。 - partitioner指的是用户自定义的分区类重写partition方法。  - field指的是partitioner的输入参数。  - keySelector指的是用户自定义的partitioner的输入参数。   |
| public \<K\> DataStream\<T\> partitionCustom(Partitioner\<K\> partitioner, KeySelector\<T, K\> keySelector) | 使用一个用户自定义的Partitioner对每一个元素选择目标task。 - partitioner指的是用户自定义的分区类重写partition方法。  - field指的是partitioner的输入参数。  - keySelector指的是用户自定义的partitioner的输入参数。   |
| public DataStream\<T\> shuffle()                                                                            | 以均匀分布的形式将元素随机地进行分区。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| public DataStream\<T\> rebalance()                                                                          | 基于round-robin对元素进行分区，使得每个分区负责均衡。对于存在数据倾斜的性能优化是很有用的。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| public DataStream\<T\> rescale()                                                                            | 以round-robin的形式将元素分区到下游操作的子集中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| public DataStream\<T\> broadcast()                                                                          | 广播每个元素到所有分区。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
   
#### 提供project的能力
表6提供project的能力的相关接口 
| **API**                                                                                 | **说明**                                                                                                                                                                                                                              |
|:---|:---|
| public \<R extends Tuple\> SingleOutputStreamOperator\<R\> project(int... fieldIndexes) | 从元组中选择了一部分字段子集。 fieldIndexes指的是需要选择的元组中的某几个序列。 说明： 只支持Tuple数据类型的project投影。 |
   
#### 提供设置eventtime属性的能力
表7提供设置eventtime属性的能力的相关接口 
| **API**                                                                                                                                   | **说明**                                    |
|:---|:---|
| public SingleOutputStreamOperator\<T\> assignTimestampsAndWatermarks(AssignerWithPeriodicWatermarks\<T\> timestampAndWatermarkAssigner)   | 为了能让event time窗口可以正常触发窗口计算操作，需要从记录中提取时间戳。 |
| public SingleOutputStreamOperator\<T\> assignTimestampsAndWatermarks(AssignerWithPunctuatedWatermarks\<T\> timestampAndWatermarkAssigner) | 为了能让event time窗口可以正常触发窗口计算操作，需要从记录中提取时间戳。 |
   
根据接口参数不同可以分为以上两种，AssignerWithPeriodicWatermarks和AssignerWithPunctuatedWatermarks的区别如[表8]所示。
 表8接口参数区别 
| 参数                               | 说明                                                                                      |
|:---|:---|
| AssignerWithPeriodicWatermarks   | 根据StreamExecutionEnvironment类的getConfig().setAutoWatermarkInterval(200L)时间戳生成Watermark。 |
| AssignerWithPunctuatedWatermarks | 每接收到一个元素，都会生成一个Watermark，而且可以根据接收到的元素生成不同的Watermark。                                    |
   
#### 提供迭代的能力
表9提供迭代的能力的相关接口 
| **API**                                                     | **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|:---|:---|
| public IterativeStream\<T\> iterate()                       | 在流(flow)中创建一个带反馈的循环，通过重定向一个operator的输出到之前的operator。 说明： - 对于定义一些需要不断更新模型的算法是非常有帮助的。  - long maxWaitTimeMillis：该超时时间指的是每一轮迭代体执行的超时时间。   |
| public IterativeStream\<T\> iterate(long maxWaitTimeMillis) | 在流(flow)中创建一个带反馈的循环，通过重定向一个operator的输出到之前的operator。 说明： - 对于定义一些需要不断更新模型的算法是非常有帮助的。  - long maxWaitTimeMillis：该超时时间指的是每一轮迭代体执行的超时时间。   |
   
#### 提供分流能力
表10提供分流能力的相关接口 
| **API**                                                           | **说明**                                                                                                              |
|:---|:---|
| public SplitStream\<T\> split(OutputSelector\<T\> outputSelector) | 传入OutputSelector，重写select方法确定分流的依据(即打标记)，构建SplitStream流。即对每个元素做一个字符串的标记，作为选择的依据，打好标记之后就可以通过标记选出并新建某个标记的流。           |
| public DataStream\<OUT\> select(String... outputNames)            | 从一个SplitStream中选出一个或多个流。 outputNames指的是使用split方法对每个元素做的字符串标记的序列。 |
   
#### 窗口能力
窗口分为跳跃窗口和滑动窗口。
- 支持Window、TimeWindow、CountWindow以及WindowAll、TimeWindowAll、CountWindowAll API窗口生成。
- 支持Window Apply、Window Reduce、Window Fold、Aggregations on windows API窗口操作。
- 支持多种Window Assigner（TumblingEventTimeWindows、TumblingProcessingTimeWindows、SlidingEventTimeWindows、SlidingProcessingTimeWindows、EventTimeSessionWindows、ProcessingTimeSessionWindows、GlobalWindows）。
- 支持三种时间ProcessingTime、EventTime和IngestionTime。
- 支持两种EventTime时间戳方式：AssignerWithPeriodicWatermarks和AssignerWithPunctuatedWatermarks。
窗口生成类API如[表11]所示。
 表11窗口生成类的相关接口 
| **API**                                                                                                  | **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|:---|:---|
| public \<W extends Window\> WindowedStream\<T, KEY, W\> window(WindowAssigner\<? super T, W\> assigner)  | 窗口可以被定义在已经被分区的KeyedStreams上。窗口会对数据的每一个key根据一些特征（例如在最近5秒钟内到达的数据）进行分组。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| public \<W extends Window\> AllWindowedStream\<T, W\> windowAll(WindowAssigner\<? super T, W\> assigner) | 窗口可以被定义在DataStream上。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| public WindowedStream\<T, KEY, TimeWindow\> timeWindow(Time size)                                        | 时间窗口定义在已经被分区的KeyedStreams上，根据environment.getStreamTimeCharacteristic()参数选择是ProcessingTime还是EventTime，根据参数个数确定是TumblingWindow还是SlidingWindow。 - size指的是窗口时间的大小。  - slide指的是窗口的滑动时间。   说明： - WindowedStream和AllWindowedStream代表不同的两种流。  - 接口中只有一个参数则是TumblingWindow；有两个或两个以上的参数则是SlidingWindow。   |
| public WindowedStream\<T, KEY, TimeWindow\> timeWindow(Time size, Time slide)                            | 时间窗口定义在已经被分区的KeyedStreams上，根据environment.getStreamTimeCharacteristic()参数选择是ProcessingTime还是EventTime，根据参数个数确定是TumblingWindow还是SlidingWindow。 - size指的是窗口时间的大小。  - slide指的是窗口的滑动时间。   说明： - WindowedStream和AllWindowedStream代表不同的两种流。  - 接口中只有一个参数则是TumblingWindow；有两个或两个以上的参数则是SlidingWindow。   |
| public AllWindowedStream\<T, TimeWindow\> timeWindowAll(Time size)                                       | 时间窗口定义在DataStream上，根据environment.getStreamTimeCharacteristic()参数选择是ProcessingTime还是EventTime，根据参数个数确定是TumblingWindow还是SlidingWindow。 - size指的是窗口时间的大小。  - slide指的是窗口的滑动时间。                                                                                                                                                                                                                                                                                                                                                                                     |
| public AllWindowedStream\<T, TimeWindow\> timeWindowAll(Time size, Time slide)                           | 时间窗口定义在DataStream上，根据environment.getStreamTimeCharacteristic()参数选择是ProcessingTime还是EventTime，根据参数个数确定是TumblingWindow还是SlidingWindow。 - size指的是窗口时间的大小。  - slide指的是窗口的滑动时间。                                                                                                                                                                                                                                                                                                                                                                                     |
| public WindowedStream\<T, KEY, GlobalWindow\> countWindow(long size)                                     | 按照元素个数区分窗口，定义在已经被分区的KeyedStreams上。 - size指的是窗口时间的大小。  - slide指的是窗口的滑动时间。   说明： - WindowedStream和AllWindowedStream代表不同的两种流。  - 接口中只有一个参数则是TumblingWindow；有两个或两个以上的参数则是SlidingWindow。                                                                                                             |
| public WindowedStream\<T, KEY, GlobalWindow\> countWindow(long size, long slide)                         | 按照元素个数区分窗口，定义在已经被分区的KeyedStreams上。 - size指的是窗口时间的大小。  - slide指的是窗口的滑动时间。   说明： - WindowedStream和AllWindowedStream代表不同的两种流。  - 接口中只有一个参数则是TumblingWindow；有两个或两个以上的参数则是SlidingWindow。                                                                                                             |
| public AllWindowedStream\<T, GlobalWindow\> countWindowAll(Time size)                                    | 按照元素个数区分窗口，定义在DataStream上。 - size指的是窗口时间的大小。  - slide指的是窗口的滑动时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| public AllWindowedStream\<T, GlobalWindow\> countWindowAll(Time size, Time slide)                        | 按照元素个数区分窗口，定义在DataStream上。 - size指的是窗口时间的大小。  - slide指的是窗口的滑动时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
   
窗口操作类API如[表12]所示。
 表12窗口操作类的相关接口 
| **方法**           | **API**                                                                                                                                                                                                                                                                                                                                                                                                                                         | **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|:---|:---|:---|
| Window           | public \<R\> SingleOutputStreamOperator\<R\> apply(WindowFunction\<T, R, K, W\> function)                                                                                                                                                                                                                                                                                                                                                       | 应用一个一般的函数到窗口上，窗口中的数据会作为一个整体被计算。 - function指的是执行的窗口函数。  - resultType为返回的数据的类型信息。                                                                                                                                                                                                                                                                                    |
| Window           | public \<R\> SingleOutputStreamOperator\<R\> apply(WindowFunction\<T, R, K, W\> function, TypeInformation\<R\> resultType)                                                                                                                                                                                                                                                                                                                      | 应用一个一般的函数到窗口上，窗口中的数据会作为一个整体被计算。 - function指的是执行的窗口函数。  - resultType为返回的数据的类型信息。                                                                                                                                                                                                                                                                                    |
| Window           | public SingleOutputStreamOperator\<T\> reduce(ReduceFunction\<T\> function)                                                                                                                                                                                                                                                                                                                                                                     | 应用一个reduce函数到窗口上，返回reduce后的值。 - reduceFunction指的是执行的reduce函数。  - WindowFunction的function指的是在经过reduce操作之后再触发一次窗口操作。  - resultType为返回的数据的类型信息。                                                                                                                 |
| Window           | public \<R\> SingleOutputStreamOperator\<R\> reduce(ReduceFunction\<T\> reduceFunction, WindowFunction\<T, R, K, W\> function)                                                                                                                                                                                                                                                                                                                  | 应用一个reduce函数到窗口上，返回reduce后的值。 - reduceFunction指的是执行的reduce函数。  - WindowFunction的function指的是在经过reduce操作之后再触发一次窗口操作。  - resultType为返回的数据的类型信息。                                                                                                                 |
| Window           | public \<R\> SingleOutputStreamOperator\<R\> reduce( ReduceFunction\<T\> reduceFunction, WindowFunction\<T, R, K, W\> function, TypeInformation\<R\> resultType)                                                                                                                       | 应用一个reduce函数到窗口上，返回reduce后的值。 - reduceFunction指的是执行的reduce函数。  - WindowFunction的function指的是在经过reduce操作之后再触发一次窗口操作。  - resultType为返回的数据的类型信息。                                                                                                                 |
| Window           | public \<R\> SingleOutputStreamOperator\<R\> fold(R initialValue, FoldFunction\<T, R\> function)                                                                                                                                                                                                                                                                                                                                                | 应用一个fold函数到窗口上，然后返回折叠后的值。 - initialValue指的是初始值。  - foldFunction指的是折叠函数。  - WindowFunction的function指的是在经过fold操作之后再触发一次窗口操作。  - resultType为返回的数据的类型信息。   |
| Window           | public \<R\> SingleOutputStreamOperator\<R\> fold(R initialValue, FoldFunction\<T, R\> function, TypeInformation\<R\> resultType)                                                                                                                                                                                                                                                                                                               | 应用一个fold函数到窗口上，然后返回折叠后的值。 - initialValue指的是初始值。  - foldFunction指的是折叠函数。  - WindowFunction的function指的是在经过fold操作之后再触发一次窗口操作。  - resultType为返回的数据的类型信息。   |
| Window           | public \<ACC, R\> SingleOutputStreamOperator\<R\> fold(ACC initialValue, FoldFunction\<T, ACC\> foldFunction, WindowFunction\<ACC, R, K, W\> function)                                                                                                                                                                                                                                                                                          | 应用一个fold函数到窗口上，然后返回折叠后的值。 - initialValue指的是初始值。  - foldFunction指的是折叠函数。  - WindowFunction的function指的是在经过fold操作之后再触发一次窗口操作。  - resultType为返回的数据的类型信息。   |
| Window           | public \<ACC, R\> SingleOutputStreamOperator\<R\> fold(ACC initialValue, FoldFunction\<T, ACC\> foldFunction, WindowFunction\<ACC, R, K, W\> function, TypeInformation\<ACC\> foldAccumulatorType, TypeInformation\<R\> resultType)                                                                                                                                                                                                             | 应用一个fold函数到窗口上，然后返回折叠后的值。 - initialValue指的是初始值。  - foldFunction指的是折叠函数。  - WindowFunction的function指的是在经过fold操作之后再触发一次窗口操作。  - resultType为返回的数据的类型信息。   |
| WindowAll        | public \<R\> SingleOutputStreamOperator\<R\> apply(AllWindowFunction\<T, R, W\> function)                                                                                                                                                                                                                                                                                                                                                       | 应用一个一般的函数到窗口上，窗口中的数据会作为一个整体被计算。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| WindowAll        | public \<R\> SingleOutputStreamOperator\<R\> apply(AllWindowFunction\<T, R, W\> function, TypeInformation\<R\> resultType)                                                                                                                                                                                                                                                                                                                      | 应用一个一般的函数到窗口上，窗口中的数据会作为一个整体被计算。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| WindowAll        | public SingleOutputStreamOperator\<T\> reduce(ReduceFunction\<T\> function)                                                                                                                                                                                                                                                                                                                                                                     | 应用一个reduce函数到窗口上，返回reduce后的值。 - reduceFunction指的是执行的reduce函数。  - AllWindowFunction的function指的是在经过reduce操作之后再触发一次窗口操作。  - resultType为返回的数据的类型信息。                                                                                                              |
| WindowAll        | public \<R\> SingleOutputStreamOperator\<R\> reduce(ReduceFunction\<T\> reduceFunction, AllWindowFunction\<T, R, W\> function)                                                                                                                                                                                                                                                                                                                  | 应用一个reduce函数到窗口上，返回reduce后的值。 - reduceFunction指的是执行的reduce函数。  - AllWindowFunction的function指的是在经过reduce操作之后再触发一次窗口操作。  - resultType为返回的数据的类型信息。                                                                                                              |
| WindowAll        | public \<R\> SingleOutputStreamOperator\<R\> reduce(ReduceFunction\<T\> reduceFunction, AllWindowFunction\<T, R, W\> function, TypeInformation\<R\> resultType)                                                                                                                                                                                                                                                                                 | 应用一个reduce函数到窗口上，返回reduce后的值。 - reduceFunction指的是执行的reduce函数。  - AllWindowFunction的function指的是在经过reduce操作之后再触发一次窗口操作。  - resultType为返回的数据的类型信息。                                                                                                              |
| WindowAll        | public \<R\> SingleOutputStreamOperator\<R\> fold(R initialValue, FoldFunction\<T, R\> function)                                                                                                                                                                                                                                                                                                                                                | 应用一个fold函数到窗口上，然后返回折叠后的值。 - initialValue指的是初始值。  - foldFunction指的是折叠函数。  - WindowFunction的function指的是在经过fold操作之后再触发一次窗口操作。  - resultType为返回的数据的类型信息。   |
| WindowAll        | public \<R\> SingleOutputStreamOperator\<R\> fold(R initialValue, FoldFunction\<T, R\> function, TypeInformation\<R\> resultType)                                                                                                                                                                                                                                                                                                               | 应用一个fold函数到窗口上，然后返回折叠后的值。 - initialValue指的是初始值。  - foldFunction指的是折叠函数。  - WindowFunction的function指的是在经过fold操作之后再触发一次窗口操作。  - resultType为返回的数据的类型信息。   |
| WindowAll        | public \<ACC, R\> SingleOutputStreamOperator\<R\> fold(ACC initialValue, FoldFunction\<T, ACC\> foldFunction, AllWindowFunction\<ACC, R, W\> function)                                                                                                                                                                                                                                                                                          | 应用一个fold函数到窗口上，然后返回折叠后的值。 - initialValue指的是初始值。  - foldFunction指的是折叠函数。  - WindowFunction的function指的是在经过fold操作之后再触发一次窗口操作。  - resultType为返回的数据的类型信息。   |
| WindowAll        | public \<ACC, R\> SingleOutputStreamOperator\<R\> fold(ACC initialValue, FoldFunction\<T, ACC\> foldFunction, AllWindowFunction\<ACC, R, W\> function, TypeInformation\<ACC\> foldAccumulatorType, TypeInformation\<R\> resultType) | 应用一个fold函数到窗口上，然后返回折叠后的值。 - initialValue指的是初始值。  - foldFunction指的是折叠函数。  - WindowFunction的function指的是在经过fold操作之后再触发一次窗口操作。  - resultType为返回的数据的类型信息。   |
| Window和WindowAll | public SingleOutputStreamOperator\<T\> sum(int positionToSum)                                                                                                                                                                                                                                                                                                                                                                                   | 对窗口数据的某一列求和。 positionToSum和field代表数据的某一列。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Window和WindowAll | public SingleOutputStreamOperator\<T\> sum(String field)                                                                                                                                                                                                                                                                                                                                                                                        | 对窗口数据的某一列求和。 positionToSum和field代表数据的某一列。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Window和WindowAll | public SingleOutputStreamOperator\<T\> min(int positionToMin)                                                                                                                                                                                                                                                                                                                                                                                   | 对窗口数据的某一列求最小值。min返回了最小值，不保证非最小值列的准确性。 positionToMin和field代表对某一列求最小值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Window和WindowAll | public SingleOutputStreamOperator\<T\> min(String field)                                                                                                                                                                                                                                                                                                                                                                                        | 对窗口数据的某一列求最小值。min返回了最小值，不保证非最小值列的准确性。 positionToMin和field代表对某一列求最小值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Window和WindowAll | public SingleOutputStreamOperator\<T\> minBy(int positionToMinBy)                                                                                                                                                                                                                                                                                                                                                                               | 对窗口数据的某一列求最小值所在的该行数据，minBy返回了该行数据的所有元素。 - positionToMinBy代表对哪一列做minBy操作。  - first表示是否按最先遇到的最小值输出还是最后遇到的最小值输出。                                                                                                                                                                                                                                                      |
| Window和WindowAll | public SingleOutputStreamOperator\<T\> minBy(String positionToMinBy)                                                                                                                                                                                                                                                                                                                                                                            | 对窗口数据的某一列求最小值所在的该行数据，minBy返回了该行数据的所有元素。 - positionToMinBy代表对哪一列做minBy操作。  - first表示是否按最先遇到的最小值输出还是最后遇到的最小值输出。                                                                                                                                                                                                                                                      |
| Window和WindowAll | public SingleOutputStreamOperator\<T\> minBy(int positionToMinBy, boolean first)                                                                                                                                                                                                                                                                                                                                                                | 对窗口数据的某一列求最小值所在的该行数据，minBy返回了该行数据的所有元素。 - positionToMinBy代表对哪一列做minBy操作。  - first表示是否按最先遇到的最小值输出还是最后遇到的最小值输出。                                                                                                                                                                                                                                                      |
| Window和WindowAll | public SingleOutputStreamOperator\<T\> minBy(String field, boolean first)                                                                                                                                                                                                                                                                                                                                                                       | 对窗口数据的某一列求最小值所在的该行数据，minBy返回了该行数据的所有元素。 - positionToMinBy代表对哪一列做minBy操作。  - first表示是否按最先遇到的最小值输出还是最后遇到的最小值输出。                                                                                                                                                                                                                                                      |
| Window和WindowAll | public SingleOutputStreamOperator\<T\> max(int positionToMax)                                                                                                                                                                                                                                                                                                                                                                                   | 对窗口数据的某一列求最大值。max返回了最大值，不保证非最大值列的准确性。 positionToMax和field代表对某一列求最大值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Window和WindowAll | public SingleOutputStreamOperator\<T\> max(String field)                                                                                                                                                                                                                                                                                                                                                                                        | 对窗口数据的某一列求最大值。max返回了最大值，不保证非最大值列的准确性。 positionToMax和field代表对某一列求最大值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Window和WindowAll | public SingleOutputStreamOperator\<T\> maxBy(int positionToMaxBy)//默认true                                                                                                                                                                                                                                                                                                                                                                       | 对窗口数据的某一列求最大值所在的该行数据，maxBy返回了在这个字段上是最大值的所有元素。 - positionToMaxBy代表对哪一列做maxBy操作。  - first表示是否按最先遇到的最大值输出还是最后遇到的最大值输出。                                                                                                                                                                                                                                                |
| Window和WindowAll | public SingleOutputStreamOperator\<T\> maxBy(String positionToMaxBy)//默认true                                                                                                                                                                                                                                                                                                                                                                    | 对窗口数据的某一列求最大值所在的该行数据，maxBy返回了在这个字段上是最大值的所有元素。 - positionToMaxBy代表对哪一列做maxBy操作。  - first表示是否按最先遇到的最大值输出还是最后遇到的最大值输出。                                                                                                                                                                                                                                                |
| Window和WindowAll | public SingleOutputStreamOperator\<T\> maxBy(int positionToMaxBy, boolean first)                                                                                                                                                                                                                                                                                                                                                                | 对窗口数据的某一列求最大值所在的该行数据，maxBy返回了在这个字段上是最大值的所有元素。 - positionToMaxBy代表对哪一列做maxBy操作。  - first表示是否按最先遇到的最大值输出还是最后遇到的最大值输出。                                                                                                                                                                                                                                                |
| Window和WindowAll | public SingleOutputStreamOperator\<T\> maxBy(String field, boolean first)                                                                                                                                                                                                                                                                                                                                                                       | 对窗口数据的某一列求最大值所在的该行数据，maxBy返回了在这个字段上是最大值的所有元素。 - positionToMaxBy代表对哪一列做maxBy操作。  - first表示是否按最先遇到的最大值输出还是最后遇到的最大值输出。                                                                                                                                                                                                                                                |
   
#### 提供多流合并的能力
表13提供多流合并的能力的相关接口 
| **API**                                                                                             | **说明**                                                                                                                                                                                  |
|:---|:---|
| public final DataStream\<T\> union(DataStream\<T\>... streams)                                      | Union两个或多个数据流，生成一个新的包含了来自所有流的所有数据的数据流。 说明： 如果你将一个数据流与其自身进行了合并，在结果流中对于每个元素你都会拿到两份。 |
| public \<R\> ConnectedStreams\<T, R\> connect(DataStream\<R\> dataStream)                           | "连接"两个数据流并保持原先的类型。Connect可以让两条流之间共享状态。产生ConnectedStreams之后，调用map或者flatmap进行操作计算。                                                                                                        |
| public \<R\> SingleOutputStreamOperator\<R\> map(CoMapFunction\<IN1, IN2, R\> coMapper)             | 在ConnectedStreams上做元素映射，类似DataStream的map操作，元素映射之后流数据类型统一。                                                                                                                               |
| public \<R\> SingleOutputStreamOperator\<R\> flatMap(CoFlatMapFunction\<IN1, IN2, R\> coFlatMapper) | 在ConnectedStreams上做元素映射，类似DataStream的flatMap操作，元素映射之后流数据类型统一。                                                                                                                           |
   
#### 提供Join能力
表14提供Join能力的相关接口 
| **API**                                                                       | **说明**                         |
|:---|:---|
| public \<T2\> JoinedStreams\<T, T2\> join(DataStream\<T2\> otherStream)       | 通过给定的key在一个窗口范围内join两条数据流。     |
| public \<T2\> CoGroupedStreams\<T, T2\> coGroup(DataStream\<T2\> otherStream) | 通过给定的key在一个窗口范围内co-group两条数据流。 |