org.apache.flink.streaming.api.datastream

类 WindowedStream<T,K,W extends Window>

java.lang.Object

org.apache.flink.streaming.api.datastream.WindowedStream<T,K,W>

类型参数:

T - The type of elements in the stream.

K - The type of the key by which elements are grouped.

W - The type of Window that the WindowAssigner assigns the elements to.

@Public
public class WindowedStream<T,K,W extends Window>
extends Object

A WindowedStream represents a data stream where elements are grouped by key, and for each key, the stream of elements is split into windows based on a WindowAssigner. Window emission is triggered based on a Trigger.

The windows are conceptually evaluated for each key individually, meaning windows can trigger at different points for each key.

If an Evictor is specified it will be used to evict elements from the window after evaluation was triggered by the Trigger but before the actual evaluation of the window. When using an evictor window performance will degrade significantly, since incremental aggregation of window results cannot be used.

Note that the WindowedStream is purely an API construct, during runtime the WindowedStream will be collapsed together with the KeyedStream and the operation over the window into one single operation.

构造器概要

构造器

构造器和说明
WindowedStream(KeyedStream<T,K> input, WindowAssigner<? super T,W> windowAssigner)

方法概要

限定符和类型	方法和说明
<ACC,R> SingleOutputStreamOperator<R>	aggregate(org.apache.flink.api.common.functions.AggregateFunction<T,ACC,R> function) Applies the given aggregation function to each window.
<ACC,R> SingleOutputStreamOperator<R>	aggregate(org.apache.flink.api.common.functions.AggregateFunction<T,ACC,R> function, org.apache.flink.api.common.typeinfo.TypeInformation<ACC> accumulatorType, org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType) Applies the given aggregation function to each window.
<ACC,V,R> SingleOutputStreamOperator<R>	aggregate(org.apache.flink.api.common.functions.AggregateFunction<T,ACC,V> aggFunction, ProcessWindowFunction<V,R,K,W> windowFunction) Applies the given window function to each window.
<ACC,V,R> SingleOutputStreamOperator<R>	aggregate(org.apache.flink.api.common.functions.AggregateFunction<T,ACC,V> aggregateFunction, ProcessWindowFunction<V,R,K,W> windowFunction, org.apache.flink.api.common.typeinfo.TypeInformation<ACC> accumulatorType, org.apache.flink.api.common.typeinfo.TypeInformation<V> aggregateResultType, org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType) Applies the given window function to each window.
<ACC,V,R> SingleOutputStreamOperator<R>	aggregate(org.apache.flink.api.common.functions.AggregateFunction<T,ACC,V> aggFunction, WindowFunction<V,R,K,W> windowFunction) Applies the given window function to each window.
<ACC,V,R> SingleOutputStreamOperator<R>	aggregate(org.apache.flink.api.common.functions.AggregateFunction<T,ACC,V> aggregateFunction, WindowFunction<V,R,K,W> windowFunction, org.apache.flink.api.common.typeinfo.TypeInformation<ACC> accumulatorType, org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType) Applies the given window function to each window.
WindowedStream<T,K,W>	allowedLateness(Time lateness) Sets the time by which elements are allowed to be late.
<R> SingleOutputStreamOperator<R>	apply(org.apache.flink.api.common.functions.ReduceFunction<T> reduceFunction, WindowFunction<T,R,K,W> function) 已过时。 Use reduce(ReduceFunction, WindowFunction) instead.
<R> SingleOutputStreamOperator<R>	apply(org.apache.flink.api.common.functions.ReduceFunction<T> reduceFunction, WindowFunction<T,R,K,W> function, org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType) 已过时。 Use reduce(ReduceFunction, WindowFunction, TypeInformation) instead.
<R> SingleOutputStreamOperator<R>	apply(R initialValue, org.apache.flink.api.common.functions.FoldFunction<T,R> foldFunction, WindowFunction<R,R,K,W> function) 已过时。 Use fold(Object, FoldFunction, WindowFunction) instead.
<R> SingleOutputStreamOperator<R>	apply(R initialValue, org.apache.flink.api.common.functions.FoldFunction<T,R> foldFunction, WindowFunction<R,R,K,W> function, org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType) 已过时。 Use fold(Object, FoldFunction, WindowFunction, TypeInformation, TypeInformation) instead.
<R> SingleOutputStreamOperator<R>	apply(WindowFunction<T,R,K,W> function) Applies the given window function to each window.
<R> SingleOutputStreamOperator<R>	apply(WindowFunction<T,R,K,W> function, org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType) Applies the given window function to each window.
WindowedStream<T,K,W>	evictor(Evictor<? super T,? super W> evictor) Sets the Evictor that should be used to evict elements from a window before emission.
<R,ACC> SingleOutputStreamOperator<R>	fold(ACC initialValue, org.apache.flink.api.common.functions.FoldFunction<T,ACC> foldFunction, ProcessWindowFunction<ACC,R,K,W> windowFunction) 已过时。 use aggregate(AggregateFunction, WindowFunction) instead
<R,ACC> SingleOutputStreamOperator<R>	fold(ACC initialValue, org.apache.flink.api.common.functions.FoldFunction<T,ACC> foldFunction, ProcessWindowFunction<ACC,R,K,W> windowFunction, org.apache.flink.api.common.typeinfo.TypeInformation<ACC> foldResultType, org.apache.flink.api.common.typeinfo.TypeInformation<R> windowResultType) 已过时。 use aggregate(AggregateFunction, WindowFunction, TypeInformation, TypeInformation) instead
<ACC,R> SingleOutputStreamOperator<R>	fold(ACC initialValue, org.apache.flink.api.common.functions.FoldFunction<T,ACC> foldFunction, WindowFunction<ACC,R,K,W> function) 已过时。 use aggregate(AggregateFunction, WindowFunction) instead
<ACC,R> SingleOutputStreamOperator<R>	fold(ACC initialValue, org.apache.flink.api.common.functions.FoldFunction<T,ACC> foldFunction, WindowFunction<ACC,R,K,W> function, org.apache.flink.api.common.typeinfo.TypeInformation<ACC> foldAccumulatorType, org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType) 已过时。 use aggregate(AggregateFunction, ProcessWindowFunction, TypeInformation, TypeInformation, TypeInformation) instead
<R> SingleOutputStreamOperator<R>	fold(R initialValue, org.apache.flink.api.common.functions.FoldFunction<T,R> function) 已过时。 use aggregate(AggregationFunction) instead
<R> SingleOutputStreamOperator<R>	fold(R initialValue, org.apache.flink.api.common.functions.FoldFunction<T,R> function, org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType) 已过时。 use aggregate(AggregateFunction, TypeInformation, TypeInformation) instead
StreamExecutionEnvironment	getExecutionEnvironment()
org.apache.flink.api.common.typeinfo.TypeInformation<T>	getInputType()
SingleOutputStreamOperator<T>	max(int positionToMax) Applies an aggregation that gives the maximum value of every window of the data stream at the given position.
SingleOutputStreamOperator<T>	max(String field) Applies an aggregation that that gives the maximum value of the pojo data stream at the given field expression for every window.
SingleOutputStreamOperator<T>	maxBy(int positionToMaxBy) Applies an aggregation that gives the maximum element of every window of the data stream by the given position.
SingleOutputStreamOperator<T>	maxBy(int positionToMaxBy, boolean first) Applies an aggregation that gives the maximum element of every window of the data stream by the given position.
SingleOutputStreamOperator<T>	maxBy(String field) Applies an aggregation that gives the maximum element of every window of the data stream by the given field.
SingleOutputStreamOperator<T>	maxBy(String field, boolean first) Applies an aggregation that that gives the maximum element of the pojo data stream by the given field expression for every window.
SingleOutputStreamOperator<T>	min(int positionToMin) Applies an aggregation that that gives the minimum value of every window of the data stream at the given position.
SingleOutputStreamOperator<T>	min(String field) Applies an aggregation that that gives the minimum value of the pojo data stream at the given field expression for every window.
SingleOutputStreamOperator<T>	minBy(int positionToMinBy) Applies an aggregation that gives the minimum element of every window of the data stream by the given position.
SingleOutputStreamOperator<T>	minBy(int positionToMinBy, boolean first) Applies an aggregation that gives the minimum element of every window of the data stream by the given position.
SingleOutputStreamOperator<T>	minBy(String field) Applies an aggregation that gives the minimum element of every window of the data stream by the given field.
SingleOutputStreamOperator<T>	minBy(String field, boolean first) Applies an aggregation that that gives the minimum element of the pojo data stream by the given field expression for every window.
<R> SingleOutputStreamOperator<R>	process(ProcessWindowFunction<T,R,K,W> function) Applies the given window function to each window.
<R> SingleOutputStreamOperator<R>	process(ProcessWindowFunction<T,R,K,W> function, org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType) Applies the given window function to each window.
SingleOutputStreamOperator<T>	reduce(org.apache.flink.api.common.functions.ReduceFunction<T> function) Applies a reduce function to the window.
<R> SingleOutputStreamOperator<R>	reduce(org.apache.flink.api.common.functions.ReduceFunction<T> reduceFunction, ProcessWindowFunction<T,R,K,W> function) Applies the given window function to each window.
<R> SingleOutputStreamOperator<R>	reduce(org.apache.flink.api.common.functions.ReduceFunction<T> reduceFunction, ProcessWindowFunction<T,R,K,W> function, org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType) Applies the given window function to each window.
<R> SingleOutputStreamOperator<R>	reduce(org.apache.flink.api.common.functions.ReduceFunction<T> reduceFunction, WindowFunction<T,R,K,W> function) Applies the given window function to each window.
<R> SingleOutputStreamOperator<R>	reduce(org.apache.flink.api.common.functions.ReduceFunction<T> reduceFunction, WindowFunction<T,R,K,W> function, org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType) Applies the given window function to each window.
WindowedStream<T,K,W>	sideOutputLateData(org.apache.flink.util.OutputTag<T> outputTag) Send late arriving data to the side output identified by the given OutputTag.
SingleOutputStreamOperator<T>	sum(int positionToSum) Applies an aggregation that sums every window of the data stream at the given position.
SingleOutputStreamOperator<T>	sum(String field) Applies an aggregation that sums every window of the pojo data stream at the given field for every window.
WindowedStream<T,K,W>	trigger(Trigger<? super T,? super W> trigger) Sets the Trigger that should be used to trigger window emission.

从类继承的方法 java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

构造器详细资料

WindowedStream

@PublicEvolving
public WindowedStream(KeyedStream<T,K> input,
                                      WindowAssigner<? super T,W> windowAssigner)

方法详细资料

trigger

@PublicEvolving
public WindowedStream<T,K,W> trigger(Trigger<? super T,? super W> trigger)

Sets the Trigger that should be used to trigger window emission.

allowedLateness

@PublicEvolving
public WindowedStream<T,K,W> allowedLateness(Time lateness)

Sets the time by which elements are allowed to be late. Elements that arrive behind the watermark by more than the specified time will be dropped. By default, the allowed lateness is 0L.

Setting an allowed lateness is only valid for event-time windows.

sideOutputLateData

@PublicEvolving
public WindowedStream<T,K,W> sideOutputLateData(org.apache.flink.util.OutputTag<T> outputTag)

Send late arriving data to the side output identified by the given OutputTag. Data is considered late after the watermark has passed the end of the window plus the allowed lateness set using allowedLateness(Time).

You can get the stream of late data using SingleOutputStreamOperator.getSideOutput(OutputTag) on the SingleOutputStreamOperator resulting from the windowed operation with the same OutputTag.

evictor

@PublicEvolving
public WindowedStream<T,K,W> evictor(Evictor<? super T,? super W> evictor)

Sets the Evictor that should be used to evict elements from a window before emission.

Note: When using an evictor window performance will degrade significantly, since incremental aggregation of window results cannot be used.

reduce

public SingleOutputStreamOperator<T> reduce(org.apache.flink.api.common.functions.ReduceFunction<T> function)

Applies a reduce function to the window. The window function is called for each evaluation of the window for each key individually. The output of the reduce function is interpreted as a regular non-windowed stream.

This window will try and incrementally aggregate data as much as the window policies permit. For example, tumbling time windows can aggregate the data, meaning that only one element per key is stored. Sliding time windows will aggregate on the granularity of the slide interval, so a few elements are stored per key (one per slide interval). Custom windows may not be able to incrementally aggregate, or may need to store extra values in an aggregation tree.

参数:

function - The reduce function.

返回:

The data stream that is the result of applying the reduce function to the window.

reduce

public <R> SingleOutputStreamOperator<R> reduce(org.apache.flink.api.common.functions.ReduceFunction<T> reduceFunction,
                                                WindowFunction<T,R,K,W> function)

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given reducer.

参数:

reduceFunction - The reduce function that is used for incremental aggregation.

function - The window function.

返回:

The data stream that is the result of applying the window function to the window.

reduce

public <R> SingleOutputStreamOperator<R> reduce(org.apache.flink.api.common.functions.ReduceFunction<T> reduceFunction,
                                                WindowFunction<T,R,K,W> function,
                                                org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType)

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given reducer.

参数:

reduceFunction - The reduce function that is used for incremental aggregation.

function - The window function.

resultType - Type information for the result type of the window function.

返回:

The data stream that is the result of applying the window function to the window.

reduce

@PublicEvolving
public <R> SingleOutputStreamOperator<R> reduce(org.apache.flink.api.common.functions.ReduceFunction<T> reduceFunction,
                                                                ProcessWindowFunction<T,R,K,W> function)

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given reducer.

参数:

reduceFunction - The reduce function that is used for incremental aggregation.

function - The window function.

返回:

The data stream that is the result of applying the window function to the window.

reduce

@Internal
public <R> SingleOutputStreamOperator<R> reduce(org.apache.flink.api.common.functions.ReduceFunction<T> reduceFunction,
                                                          ProcessWindowFunction<T,R,K,W> function,
                                                          org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType)

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given reducer.

参数:

reduceFunction - The reduce function that is used for incremental aggregation.

function - The window function.

resultType - Type information for the result type of the window function

返回:

The data stream that is the result of applying the window function to the window.

fold

@Deprecated
public <R> SingleOutputStreamOperator<R> fold(R initialValue,
                                                          org.apache.flink.api.common.functions.FoldFunction<T,R> function)

已过时。 use aggregate(AggregationFunction) instead

Applies the given fold function to each window. The window function is called for each evaluation of the window for each key individually. The output of the reduce function is interpreted as a regular non-windowed stream.

参数:

function - The fold function.

返回:

The data stream that is the result of applying the fold function to the window.

fold

@Deprecated
public <R> SingleOutputStreamOperator<R> fold(R initialValue,
                                                          org.apache.flink.api.common.functions.FoldFunction<T,R> function,
                                                          org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType)

已过时。 use aggregate(AggregateFunction, TypeInformation, TypeInformation) instead

Applies the given fold function to each window. The window function is called for each evaluation of the window for each key individually. The output of the reduce function is interpreted as a regular non-windowed stream.

参数:

function - The fold function.

返回:

The data stream that is the result of applying the fold function to the window.

fold

@PublicEvolving
 @Deprecated
public <ACC,R> SingleOutputStreamOperator<R> fold(ACC initialValue,
                                                                               org.apache.flink.api.common.functions.FoldFunction<T,ACC> foldFunction,
                                                                               WindowFunction<ACC,R,K,W> function)

已过时。 use aggregate(AggregateFunction, WindowFunction) instead

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given fold function.

参数:

initialValue - The initial value of the fold.

foldFunction - The fold function that is used for incremental aggregation.

function - The window function.

返回:

The data stream that is the result of applying the window function to the window.

fold

@PublicEvolving
 @Deprecated
public <ACC,R> SingleOutputStreamOperator<R> fold(ACC initialValue,
                                                                               org.apache.flink.api.common.functions.FoldFunction<T,ACC> foldFunction,
                                                                               WindowFunction<ACC,R,K,W> function,
                                                                               org.apache.flink.api.common.typeinfo.TypeInformation<ACC> foldAccumulatorType,
                                                                               org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType)

已过时。 use aggregate(AggregateFunction, ProcessWindowFunction, TypeInformation, TypeInformation, TypeInformation) instead

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given fold function.

参数:

initialValue - The initial value of the fold.

foldFunction - The fold function that is used for incremental aggregation.

function - The window function.

foldAccumulatorType - Type information for the result type of the fold function

resultType - Type information for the result type of the window function

返回:

The data stream that is the result of applying the window function to the window.

fold

@PublicEvolving
 @Deprecated
public <R,ACC> SingleOutputStreamOperator<R> fold(ACC initialValue,
                                                                               org.apache.flink.api.common.functions.FoldFunction<T,ACC> foldFunction,
                                                                               ProcessWindowFunction<ACC,R,K,W> windowFunction)

已过时。 use aggregate(AggregateFunction, WindowFunction) instead

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given fold function.

参数:

initialValue - The initial value of the fold.

foldFunction - The fold function that is used for incremental aggregation.

windowFunction - The window function.

返回:

The data stream that is the result of applying the window function to the window.

fold

@Deprecated
 @Internal
public <R,ACC> SingleOutputStreamOperator<R> fold(ACC initialValue,
                                                                         org.apache.flink.api.common.functions.FoldFunction<T,ACC> foldFunction,
                                                                         ProcessWindowFunction<ACC,R,K,W> windowFunction,
                                                                         org.apache.flink.api.common.typeinfo.TypeInformation<ACC> foldResultType,
                                                                         org.apache.flink.api.common.typeinfo.TypeInformation<R> windowResultType)

已过时。 use aggregate(AggregateFunction, WindowFunction, TypeInformation, TypeInformation) instead

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given fold function.

参数:

initialValue - the initial value to be passed to the first invocation of the fold function

foldFunction - The fold function.

foldResultType - The result type of the fold function.

windowFunction - The process window function.

windowResultType - The process window function result type.

返回:

The data stream that is the result of applying the fold function to the window.

aggregate

@PublicEvolving
public <ACC,R> SingleOutputStreamOperator<R> aggregate(org.apache.flink.api.common.functions.AggregateFunction<T,ACC,R> function)

Applies the given aggregation function to each window. The aggregation function is called for each element, aggregating values incrementally and keeping the state to one accumulator per key and window.

类型参数:

ACC - The type of the AggregateFunction's accumulator

R - The type of the elements in the resulting stream, equal to the AggregateFunction's result type

参数:

function - The aggregation function.

返回:

The data stream that is the result of applying the fold function to the window.

aggregate

@PublicEvolving
public <ACC,R> SingleOutputStreamOperator<R> aggregate(org.apache.flink.api.common.functions.AggregateFunction<T,ACC,R> function,
                                                                       org.apache.flink.api.common.typeinfo.TypeInformation<ACC> accumulatorType,
                                                                       org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType)

Applies the given aggregation function to each window. The aggregation function is called for each element, aggregating values incrementally and keeping the state to one accumulator per key and window.

类型参数:

ACC - The type of the AggregateFunction's accumulator

R - The type of the elements in the resulting stream, equal to the AggregateFunction's result type

参数:

function - The aggregation function.

返回:

The data stream that is the result of applying the aggregation function to the window.

aggregate

@PublicEvolving
public <ACC,V,R> SingleOutputStreamOperator<R> aggregate(org.apache.flink.api.common.functions.AggregateFunction<T,ACC,V> aggFunction,
                                                                         WindowFunction<V,R,K,W> windowFunction)

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given aggregate function. This means that the window function typically has only a single value to process when called.

类型参数:

ACC - The type of the AggregateFunction's accumulator

V - The type of AggregateFunction's result, and the WindowFunction's input

R - The type of the elements in the resulting stream, equal to the WindowFunction's result type

参数:

aggFunction - The aggregate function that is used for incremental aggregation.

windowFunction - The window function.

返回:

The data stream that is the result of applying the window function to the window.

aggregate

@PublicEvolving
public <ACC,V,R> SingleOutputStreamOperator<R> aggregate(org.apache.flink.api.common.functions.AggregateFunction<T,ACC,V> aggregateFunction,
                                                                         WindowFunction<V,R,K,W> windowFunction,
                                                                         org.apache.flink.api.common.typeinfo.TypeInformation<ACC> accumulatorType,
                                                                         org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType)

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given aggregate function. This means that the window function typically has only a single value to process when called.

类型参数:

ACC - The type of the AggregateFunction's accumulator

V - The type of AggregateFunction's result, and the WindowFunction's input

R - The type of the elements in the resulting stream, equal to the WindowFunction's result type

参数:

aggregateFunction - The aggregation function that is used for incremental aggregation.

windowFunction - The window function.

accumulatorType - Type information for the internal accumulator type of the aggregation function

resultType - Type information for the result type of the window function

返回:

The data stream that is the result of applying the window function to the window.

aggregate

@PublicEvolving
public <ACC,V,R> SingleOutputStreamOperator<R> aggregate(org.apache.flink.api.common.functions.AggregateFunction<T,ACC,V> aggFunction,
                                                                         ProcessWindowFunction<V,R,K,W> windowFunction)

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given aggregate function. This means that the window function typically has only a single value to process when called.

类型参数:

ACC - The type of the AggregateFunction's accumulator

V - The type of AggregateFunction's result, and the WindowFunction's input

R - The type of the elements in the resulting stream, equal to the WindowFunction's result type

参数:

aggFunction - The aggregate function that is used for incremental aggregation.

windowFunction - The window function.

返回:

The data stream that is the result of applying the window function to the window.

aggregate

@PublicEvolving
public <ACC,V,R> SingleOutputStreamOperator<R> aggregate(org.apache.flink.api.common.functions.AggregateFunction<T,ACC,V> aggregateFunction,
                                                                         ProcessWindowFunction<V,R,K,W> windowFunction,
                                                                         org.apache.flink.api.common.typeinfo.TypeInformation<ACC> accumulatorType,
                                                                         org.apache.flink.api.common.typeinfo.TypeInformation<V> aggregateResultType,
                                                                         org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType)

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given aggregate function. This means that the window function typically has only a single value to process when called.

类型参数:

ACC - The type of the AggregateFunction's accumulator

V - The type of AggregateFunction's result, and the WindowFunction's input

R - The type of the elements in the resulting stream, equal to the WindowFunction's result type

参数:

aggregateFunction - The aggregation function that is used for incremental aggregation.

windowFunction - The window function.

accumulatorType - Type information for the internal accumulator type of the aggregation function

resultType - Type information for the result type of the window function

返回:

The data stream that is the result of applying the window function to the window.

apply

public <R> SingleOutputStreamOperator<R> apply(WindowFunction<T,R,K,W> function)

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Note that this function requires that all data in the windows is buffered until the window is evaluated, as the function provides no means of incremental aggregation.

参数:

function - The window function.

返回:

The data stream that is the result of applying the window function to the window.

apply

public <R> SingleOutputStreamOperator<R> apply(WindowFunction<T,R,K,W> function,
                                               org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType)

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Note that this function requires that all data in the windows is buffered until the window is evaluated, as the function provides no means of incremental aggregation.

参数:

function - The window function.

resultType - Type information for the result type of the window function

返回:

The data stream that is the result of applying the window function to the window.

process

@PublicEvolving
public <R> SingleOutputStreamOperator<R> process(ProcessWindowFunction<T,R,K,W> function)

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Note that this function requires that all data in the windows is buffered until the window is evaluated, as the function provides no means of incremental aggregation.

参数:

function - The window function.

返回:

The data stream that is the result of applying the window function to the window.

process

@Internal
public <R> SingleOutputStreamOperator<R> process(ProcessWindowFunction<T,R,K,W> function,
                                                           org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType)

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Note that this function requires that all data in the windows is buffered until the window is evaluated, as the function provides no means of incremental aggregation.

参数:

function - The window function.

resultType - Type information for the result type of the window function

返回:

The data stream that is the result of applying the window function to the window.

apply

@Deprecated
public <R> SingleOutputStreamOperator<R> apply(org.apache.flink.api.common.functions.ReduceFunction<T> reduceFunction,
                                                           WindowFunction<T,R,K,W> function)

已过时。 Use reduce(ReduceFunction, WindowFunction) instead.

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given reducer.

参数:

reduceFunction - The reduce function that is used for incremental aggregation.

function - The window function.

返回:

The data stream that is the result of applying the window function to the window.

apply

@Deprecated
public <R> SingleOutputStreamOperator<R> apply(org.apache.flink.api.common.functions.ReduceFunction<T> reduceFunction,
                                                           WindowFunction<T,R,K,W> function,
                                                           org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType)

已过时。 Use reduce(ReduceFunction, WindowFunction, TypeInformation) instead.

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given reducer.

参数:

reduceFunction - The reduce function that is used for incremental aggregation.

function - The window function.

resultType - Type information for the result type of the window function

返回:

The data stream that is the result of applying the window function to the window.

apply

@Deprecated
public <R> SingleOutputStreamOperator<R> apply(R initialValue,
                                                           org.apache.flink.api.common.functions.FoldFunction<T,R> foldFunction,
                                                           WindowFunction<R,R,K,W> function)

已过时。 Use fold(Object, FoldFunction, WindowFunction) instead.

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given fold function.

参数:

initialValue - The initial value of the fold.

foldFunction - The fold function that is used for incremental aggregation.

function - The window function.

返回:

The data stream that is the result of applying the window function to the window.

apply

@Deprecated
public <R> SingleOutputStreamOperator<R> apply(R initialValue,
                                                           org.apache.flink.api.common.functions.FoldFunction<T,R> foldFunction,
                                                           WindowFunction<R,R,K,W> function,
                                                           org.apache.flink.api.common.typeinfo.TypeInformation<R> resultType)

已过时。 Use fold(Object, FoldFunction, WindowFunction, TypeInformation, TypeInformation) instead.

Applies the given window function to each window. The window function is called for each evaluation of the window for each key individually. The output of the window function is interpreted as a regular non-windowed stream.

Arriving data is incrementally aggregated using the given fold function.

参数:

initialValue - The initial value of the fold.

foldFunction - The fold function that is used for incremental aggregation.

function - The window function.

resultType - Type information for the result type of the window function

返回:

The data stream that is the result of applying the window function to the window.

sum

public SingleOutputStreamOperator<T> sum(int positionToSum)

Applies an aggregation that sums every window of the data stream at the given position.

参数:

positionToSum - The position in the tuple/array to sum

返回:

The transformed DataStream.

sum

public SingleOutputStreamOperator<T> sum(String field)

Applies an aggregation that sums every window of the pojo data stream at the given field for every window.

A field expression is either the name of a public field or a getter method with parentheses of the stream's underlying type. A dot can be used to drill down into objects, as in "field1.getInnerField2()" .

参数:

field - The field to sum

返回:

The transformed DataStream.

min

public SingleOutputStreamOperator<T> min(int positionToMin)

Applies an aggregation that that gives the minimum value of every window of the data stream at the given position.

参数:

positionToMin - The position to minimize

返回:

The transformed DataStream.

min

public SingleOutputStreamOperator<T> min(String field)

Applies an aggregation that that gives the minimum value of the pojo data stream at the given field expression for every window.

A field * expression is either the name of a public field or a getter method with parentheses of the DataStreamS underlying type. A dot can be used to drill down into objects, as in "field1.getInnerField2()" .

参数:

field - The field expression based on which the aggregation will be applied.

返回:

The transformed DataStream.

minBy

public SingleOutputStreamOperator<T> minBy(int positionToMinBy)

Applies an aggregation that gives the minimum element of every window of the data stream by the given position. If more elements have the same minimum value the operator returns the first element by default.

参数:

positionToMinBy - The position to minimize by

返回:

The transformed DataStream.

minBy

public SingleOutputStreamOperator<T> minBy(String field)

Applies an aggregation that gives the minimum element of every window of the data stream by the given field. If more elements have the same minimum value the operator returns the first element by default.

参数:

field - The field to minimize by

返回:

The transformed DataStream.

minBy

public SingleOutputStreamOperator<T> minBy(int positionToMinBy,
                                           boolean first)

Applies an aggregation that gives the minimum element of every window of the data stream by the given position. If more elements have the same minimum value the operator returns either the first or last one depending on the parameter setting.

参数:

positionToMinBy - The position to minimize

first - If true, then the operator return the first element with the minimum value, otherwise returns the last

返回:

The transformed DataStream.

minBy

public SingleOutputStreamOperator<T> minBy(String field,
                                           boolean first)

Applies an aggregation that that gives the minimum element of the pojo data stream by the given field expression for every window. A field expression is either the name of a public field or a getter method with parentheses of the DataStreams underlying type. A dot can be used to drill down into objects, as in "field1.getInnerField2()" .

参数:

field - The field expression based on which the aggregation will be applied.

first - If True then in case of field equality the first object will be returned

返回:

The transformed DataStream.

max

public SingleOutputStreamOperator<T> max(int positionToMax)

Applies an aggregation that gives the maximum value of every window of the data stream at the given position.

参数:

positionToMax - The position to maximize

返回:

The transformed DataStream.

max

public SingleOutputStreamOperator<T> max(String field)

Applies an aggregation that that gives the maximum value of the pojo data stream at the given field expression for every window. A field expression is either the name of a public field or a getter method with parentheses of the DataStreams underlying type. A dot can be used to drill down into objects, as in "field1.getInnerField2()" .

参数:

field - The field expression based on which the aggregation will be applied.

返回:

The transformed DataStream.

maxBy

public SingleOutputStreamOperator<T> maxBy(int positionToMaxBy)

Applies an aggregation that gives the maximum element of every window of the data stream by the given position. If more elements have the same maximum value the operator returns the first by default.

参数:

positionToMaxBy - The position to maximize by

返回:

The transformed DataStream.

maxBy

public SingleOutputStreamOperator<T> maxBy(String field)

Applies an aggregation that gives the maximum element of every window of the data stream by the given field. If more elements have the same maximum value the operator returns the first by default.

参数:

field - The field to maximize by

返回:

The transformed DataStream.

maxBy

public SingleOutputStreamOperator<T> maxBy(int positionToMaxBy,
                                           boolean first)

Applies an aggregation that gives the maximum element of every window of the data stream by the given position. If more elements have the same maximum value the operator returns either the first or last one depending on the parameter setting.

参数:

positionToMaxBy - The position to maximize by

first - If true, then the operator return the first element with the maximum value, otherwise returns the last

返回:

The transformed DataStream.

maxBy

public SingleOutputStreamOperator<T> maxBy(String field,
                                           boolean first)

Applies an aggregation that that gives the maximum element of the pojo data stream by the given field expression for every window. A field expression is either the name of a public field or a getter method with parentheses of the DataStreamS underlying type. A dot can be used to drill down into objects, as in "field1.getInnerField2()" .

参数:

field - The field expression based on which the aggregation will be applied.

first - If True then in case of field equality the first object will be returned

返回:

The transformed DataStream.

getExecutionEnvironment

public StreamExecutionEnvironment getExecutionEnvironment()

getInputType

public org.apache.flink.api.common.typeinfo.TypeInformation<T> getInputType()