DataStream (flink-streaming-java 1.0.0 API)

java.lang.Object
- org.apache.flink.streaming.api.datastream.DataStream<T>

Type Parameters:
T - The type of the elements in this stream.

Direct Known Subclasses:

KeyedStream, SingleOutputStreamOperator, SplitStream
```
@Public
public class DataStream<T>
extends Object
```
A DataStream represents a stream of elements of the same type. A DataStream can be transformed into another DataStream by applying a transformation as for example:
- map(org.apache.flink.api.common.functions.MapFunction<T, R>)
- filter(org.apache.flink.api.common.functions.FilterFunction<T>)

Field Summary

Fields
Modifier and Type Field and Description

protected StreamExecutionEnvironment environment

protected StreamTransformation<T> transformation

Fields
Modifier and Type	Field and Description
`protected StreamExecutionEnvironment`	`environment`
`protected StreamTransformation<T>`	`transformation`

Constructor Summary

Constructors
Constructor and Description
`DataStream(StreamExecutionEnvironment environment, StreamTransformation<T> transformation)` Create a new `DataStream` in the given execution environment with partitioning set to forward by default.

Method Summary

Methods
Modifier and Type	Method and Description
`DataStreamSink<T>`	`addSink(SinkFunction<T> sinkFunction)` Adds the given sink to this DataStream.
`SingleOutputStreamOperator<T>`	`assignTimestamps(TimestampExtractor<T> extractor)` Deprecated. Please use `assignTimestampsAndWatermarks(AssignerWithPeriodicWatermarks)` of `assignTimestampsAndWatermarks(AssignerWithPunctuatedWatermarks)` instread.
`SingleOutputStreamOperator<T>`	`assignTimestampsAndWatermarks(AssignerWithPeriodicWatermarks<T> timestampAndWatermarkAssigner)` Assigns timestamps to the elements in the data stream and periodically creates watermarks to signal event time progress.
`SingleOutputStreamOperator<T>`	`assignTimestampsAndWatermarks(AssignerWithPunctuatedWatermarks<T> timestampAndWatermarkAssigner)` Assigns timestamps to the elements in the data stream and periodically creates watermarks to signal event time progress.
`DataStream<T>`	`broadcast()` Sets the partitioning of the `DataStream` so that the output elements are broadcasted to every parallel instance of the next operation.
`protected <F> F`	`clean(F f)` Invokes the `ClosureCleaner` on the given function if closure cleaning is enabled in the `ExecutionConfig`.
`<T2> CoGroupedStreams<T,T2>`	`coGroup(DataStream<T2> otherStream)` Creates a join operation.
`<R> ConnectedStreams<T,R>`	`connect(DataStream<R> dataStream)` Creates a new `ConnectedStreams` by connecting `DataStream` outputs of (possible) different types with each other.
`AllWindowedStream<T,GlobalWindow>`	`countWindowAll(long size)` Windows this `DataStream` into tumbling count windows.
`AllWindowedStream<T,GlobalWindow>`	`countWindowAll(long size, long slide)` Windows this `DataStream` into sliding count windows.
`SingleOutputStreamOperator<T>`	`filter(FilterFunction<T> filter)` Applies a Filter transformation on a `DataStream`.
`<R> SingleOutputStreamOperator<R>`	`flatMap(FlatMapFunction<T,R> flatMapper)` Applies a FlatMap transformation on a `DataStream`.
`DataStream<T>`	`forward()` Sets the partitioning of the `DataStream` so that the output elements are forwarded to the local subtask of the next operation.
`ExecutionConfig`	`getExecutionConfig()`
`StreamExecutionEnvironment`	`getExecutionEnvironment()` Returns the `StreamExecutionEnvironment` that was used to create this `DataStream`
`int`	`getId()` Returns the ID of the `DataStream` in the current `StreamExecutionEnvironment`.
`int`	`getParallelism()` Gets the parallelism for this operator.
`StreamTransformation<T>`	`getTransformation()` Returns the `StreamTransformation` that represents the operation that logically creates this `DataStream`.
`TypeInformation<T>`	`getType()` Gets the type of the stream.
`DataStream<T>`	`global()` Sets the partitioning of the `DataStream` so that the output values all go to the first instance of the next processing operator.
`IterativeStream<T>`	`iterate()` Initiates an iterative part of the program that feeds back data streams.
`IterativeStream<T>`	`iterate(long maxWaitTimeMillis)` Initiates an iterative part of the program that feeds back data streams.
`<T2> JoinedStreams<T,T2>`	`join(DataStream<T2> otherStream)` Creates a join operation.
`KeyedStream<T,Tuple>`	`keyBy(int... fields)` Partitions the operator state of a `DataStream` by the given key positions.
`<K> KeyedStream<T,K>`	`keyBy(KeySelector<T,K> key)` It creates a new `KeyedStream` that uses the provided key for partitioning its operator states.
`KeyedStream<T,Tuple>`	`keyBy(String... fields)` Partitions the operator state of a `DataStream`using field expressions.
`<R> SingleOutputStreamOperator<R>`	`map(MapFunction<T,R> mapper)` Applies a Map transformation on a `DataStream`.
`<K> DataStream<T>`	`partitionCustom(Partitioner<K> partitioner, int field)` Partitions a tuple DataStream on the specified key fields using a custom partitioner.
`<K> DataStream<T>`	`partitionCustom(Partitioner<K> partitioner, KeySelector<T,K> keySelector)` Partitions a DataStream on the key returned by the selector, using a custom partitioner.
`<K> DataStream<T>`	`partitionCustom(Partitioner<K> partitioner, String field)` Partitions a POJO DataStream on the specified key fields using a custom partitioner.
`DataStreamSink<T>`	`print()` Writes a DataStream to the standard output stream (stdout).
`DataStreamSink<T>`	`printToErr()` Writes a DataStream to the standard output stream (stderr).
`<R extends Tuple> SingleOutputStreamOperator<R>`	`project(int... fieldIndexes)` Initiates a Project transformation on a `Tuple` `DataStream`. Note: Only Tuple DataStreams can be projected.
`DataStream<T>`	`rebalance()` Sets the partitioning of the `DataStream` so that the output elements are distributed evenly to instances of the next operation in a round-robin fashion.
`DataStream<T>`	`rescale()` Sets the partitioning of the `DataStream` so that the output elements are distributed evenly to a subset of instances of the next operation in a round-robin fashion.
`protected DataStream<T>`	`setConnectionType(StreamPartitioner<T> partitioner)` Internal function for setting the partitioner for the DataStream
`DataStream<T>`	`shuffle()` Sets the partitioning of the `DataStream` so that the output elements are shuffled uniformly randomly to the next operation.
`SplitStream<T>`	`split(OutputSelector<T> outputSelector)` Operator used for directing tuples to specific named outputs using an `OutputSelector`.
`AllWindowedStream<T,TimeWindow>`	`timeWindowAll(Time size)` Windows this `DataStream` into tumbling time windows.
`AllWindowedStream<T,TimeWindow>`	`timeWindowAll(Time size, Time slide)` Windows this `DataStream` into sliding time windows.
`<R> SingleOutputStreamOperator<R>`	`transform(String operatorName, TypeInformation<R> outTypeInfo, OneInputStreamOperator<T,R> operator)` Method for passing user defined operators along with the type information that will transform the DataStream.
`DataStream<T>`	`union(DataStream<T>... streams)` Creates a new `DataStream` by merging `DataStream` outputs of the same type with each other.
`<W extends Window> AllWindowedStream<T,W>`	`windowAll(WindowAssigner<? super T,W> assigner)` Windows this data stream to a `KeyedTriggerWindowDataStream`, which evaluates windows over a key grouped stream.
`DataStreamSink<T>`	`writeAsCsv(String path)` Writes a DataStream to the file specified by the path parameter.
`DataStreamSink<T>`	`writeAsCsv(String path, FileSystem.WriteMode writeMode)` Writes a DataStream to the file specified by the path parameter.
`<X extends Tuple> DataStreamSink<T>`	`writeAsCsv(String path, FileSystem.WriteMode writeMode, String rowDelimiter, String fieldDelimiter)` Writes a DataStream to the file specified by the path parameter.
`DataStreamSink<T>`	`writeAsText(String path)` Writes a DataStream to the file specified by path in text format.
`DataStreamSink<T>`	`writeAsText(String path, FileSystem.WriteMode writeMode)` Writes a DataStream to the file specified by path in text format.
`DataStreamSink<T>`	`writeToSocket(String hostName, int port, SerializationSchema<T> schema)` Writes the DataStream to a socket as a byte array.
`DataStreamSink<T>`	`writeUsingOutputFormat(OutputFormat<T> format)` Writes the dataStream into an output, described by an OutputFormat.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - environment
```
protected final StreamExecutionEnvironment environment
```
  - transformation
```
protected final StreamTransformation<T> transformation
```
- Constructor Detail
  - DataStream
```
public DataStream(StreamExecutionEnvironment environment,
          StreamTransformation<T> transformation)
```
    Create a new DataStream in the given execution environment with partitioning set to forward by default.
    
    Parameters:
    environment - The StreamExecutionEnvironment
- Method Detail
  - getId
```
@Internal
public int getId()
```
    Returns the ID of the DataStream in the current StreamExecutionEnvironment.
    
    Returns:
    ID of the DataStream
  - getParallelism
```
public int getParallelism()
```
    Gets the parallelism for this operator.
    
    Returns:
    The parallelism set for this operator.
  - getType
```
public TypeInformation<T> getType()
```
    Gets the type of the stream.
    
    Returns:
    The type of the datastream.
  - clean
```
protected <F> F clean(F f)
```
    Invokes the ClosureCleaner on the given function if closure cleaning is enabled in the ExecutionConfig.
    
    Returns:
    The cleaned Function
  - getExecutionEnvironment
```
public StreamExecutionEnvironment getExecutionEnvironment()
```
    Returns the StreamExecutionEnvironment that was used to create this DataStream
    
    Returns:
    The Execution Environment
  - getExecutionConfig
```
public ExecutionConfig getExecutionConfig()
```
  - union
```
@SafeVarargs
public final DataStream<T> union(DataStream<T>... streams)
```
    Creates a new DataStream by merging DataStream outputs of the same type with each other. The DataStreams merged using this operator will be transformed simultaneously.
    
    Parameters:
    streams - The DataStreams to union output with.
    
    Returns:
    The DataStream.
  - split
```
public SplitStream<T> split(OutputSelector<T> outputSelector)
```
    Operator used for directing tuples to specific named outputs using an OutputSelector. Calling this method on an operator creates a new SplitStream.
    
    Parameters:
    outputSelector - The user defined OutputSelector for directing the tuples.
    
    Returns:
    The SplitStream
  - connect
```
public <R> ConnectedStreams<T,R> connect(DataStream<R> dataStream)
```
    Creates a new ConnectedStreams by connecting DataStream outputs of (possible) different types with each other. The DataStreams connected using this operator can be used with CoFunctions to apply joint transformations.
    
    Parameters:
    dataStream - The DataStream with which this stream will be connected.
    
    Returns:
    The ConnectedStreams.
  - keyBy
```
public <K> KeyedStream<T,K> keyBy(KeySelector<T,K> key)
```
    It creates a new KeyedStream that uses the provided key for partitioning its operator states.
    
    Parameters:
    key - The KeySelector to be used for extracting the key for partitioning
    
    Returns:
    The DataStream with partitioned state (i.e. KeyedStream)
  - keyBy
```
public KeyedStream<T,Tuple> keyBy(int... fields)
```
    Partitions the operator state of a DataStream by the given key positions.
    
    Parameters:
    fields - The position of the fields on which the DataStream will be grouped.
    
    Returns:
    The DataStream with partitioned state (i.e. KeyedStream)
  - keyBy
```
public KeyedStream<T,Tuple> keyBy(String... fields)
```
    Partitions the operator state of a DataStreamusing field expressions. 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()" .
    
    Parameters:
    fields - One or more field expressions on which the state of the DataStream operators will be partitioned.
    
    Returns:
    The DataStream with partitioned state (i.e. KeyedStream)
  - partitionCustom
```
public <K> DataStream<T> partitionCustom(Partitioner<K> partitioner,
                                int field)
```
    Partitions a tuple DataStream on the specified key fields using a custom partitioner. This method takes the key position to partition on, and a partitioner that accepts the key type.
    Note: This method works only on single field keys.
    
    Parameters:
    partitioner - The partitioner to assign partitions to keys.
    field - The field index on which the DataStream is to partitioned.
    
    Returns:
    The partitioned DataStream.
  - partitionCustom
```
public <K> DataStream<T> partitionCustom(Partitioner<K> partitioner,
                                String field)
```
    Partitions a POJO DataStream on the specified key fields using a custom partitioner. This method takes the key expression to partition on, and a partitioner that accepts the key type.
    Note: This method works only on single field keys.
    
    Parameters:
    partitioner - The partitioner to assign partitions to keys.
    field - The expression for the field on which the DataStream is to partitioned.
    
    Returns:
    The partitioned DataStream.
  - partitionCustom
```
public <K> DataStream<T> partitionCustom(Partitioner<K> partitioner,
                                KeySelector<T,K> keySelector)
```
    Partitions a DataStream on the key returned by the selector, using a custom partitioner. This method takes the key selector to get the key to partition on, and a partitioner that accepts the key type.
    Note: This method works only on single field keys, i.e. the selector cannot return tuples of fields.
    
    Parameters:
    partitioner - The partitioner to assign partitions to keys.
    keySelector - The KeySelector with which the DataStream is partitioned.
    
    Returns:
    The partitioned DataStream.
    See Also:
    KeySelector
  - broadcast
```
public DataStream<T> broadcast()
```
    Sets the partitioning of the DataStream so that the output elements are broadcasted to every parallel instance of the next operation.
    
    Returns:
    The DataStream with broadcast partitioning set.
  - shuffle
```
@PublicEvolving
public DataStream<T> shuffle()
```
    Sets the partitioning of the DataStream so that the output elements are shuffled uniformly randomly to the next operation.
    
    Returns:
    The DataStream with shuffle partitioning set.
  - forward
```
public DataStream<T> forward()
```
    Sets the partitioning of the DataStream so that the output elements are forwarded to the local subtask of the next operation.
    
    Returns:
    The DataStream with forward partitioning set.
  - rebalance
```
public DataStream<T> rebalance()
```
    Sets the partitioning of the DataStream so that the output elements are distributed evenly to instances of the next operation in a round-robin fashion.
    
    Returns:
    The DataStream with rebalance partitioning set.
  - rescale
```
@PublicEvolving
public DataStream<T> rescale()
```
    Sets the partitioning of the DataStream so that the output elements are distributed evenly to a subset of instances of the next operation in a round-robin fashion.
    The subset of downstream operations to which the upstream operation sends elements depends on the degree of parallelism of both the upstream and downstream operation. For example, if the upstream operation has parallelism 2 and the downstream operation has parallelism 4, then one upstream operation would distribute elements to two downstream operations while the other upstream operation would distribute to the other two downstream operations. If, on the other hand, the downstream operation has parallelism 2 while the upstream operation has parallelism 4 then two upstream operations will distribute to one downstream operation while the other two upstream operations will distribute to the other downstream operations.
    In cases where the different parallelisms are not multiples of each other one or several downstream operations will have a differing number of inputs from upstream operations.
    
    Returns:
    The DataStream with rescale partitioning set.
  - global
```
@PublicEvolving
public DataStream<T> global()
```
    Sets the partitioning of the DataStream so that the output values all go to the first instance of the next processing operator. Use this setting with care since it might cause a serious performance bottleneck in the application.
    
    Returns:
    The DataStream with shuffle partitioning set.
  - iterate
```
@PublicEvolving
public IterativeStream<T> iterate()
```
    Initiates an iterative part of the program that feeds back data streams. The iterative part needs to be closed by calling IterativeStream.closeWith(DataStream). The transformation of this IterativeStream will be the iteration head. The data stream given to the IterativeStream.closeWith(DataStream) method is the data stream that will be fed back and used as the input for the iteration head. The user can also use different feedback type than the input of the iteration and treat the input and feedback streams as a ConnectedStreams be calling IterativeStream.withFeedbackType(TypeInformation)
    A common usage pattern for streaming iterations is to use output splitting to send a part of the closing data stream to the head. Refer to split(OutputSelector) for more information.
    The iteration edge will be partitioned the same way as the first input of the iteration head unless it is changed in the IterativeStream.closeWith(DataStream) call.
    By default a DataStream with iteration will never terminate, but the user can use the maxWaitTime parameter to set a max waiting time for the iteration head. If no data received in the set time, the stream terminates.
    
    Returns:
    The iterative data stream created.
  - iterate
```
@PublicEvolving
public IterativeStream<T> iterate(long maxWaitTimeMillis)
```
    Initiates an iterative part of the program that feeds back data streams. The iterative part needs to be closed by calling IterativeStream.closeWith(DataStream). The transformation of this IterativeStream will be the iteration head. The data stream given to the IterativeStream.closeWith(DataStream) method is the data stream that will be fed back and used as the input for the iteration head. The user can also use different feedback type than the input of the iteration and treat the input and feedback streams as a ConnectedStreams be calling IterativeStream.withFeedbackType(TypeInformation)
    A common usage pattern for streaming iterations is to use output splitting to send a part of the closing data stream to the head. Refer to split(OutputSelector) for more information.
    The iteration edge will be partitioned the same way as the first input of the iteration head unless it is changed in the IterativeStream.closeWith(DataStream) call.
    By default a DataStream with iteration will never terminate, but the user can use the maxWaitTime parameter to set a max waiting time for the iteration head. If no data received in the set time, the stream terminates.
    
    Parameters:
    maxWaitTimeMillis - Number of milliseconds to wait between inputs before shutting down
    
    Returns:
    The iterative data stream created.
  - map
```
public <R> SingleOutputStreamOperator<R> map(MapFunction<T,R> mapper)
```
    Applies a Map transformation on a DataStream. The transformation calls a MapFunction for each element of the DataStream. Each MapFunction call returns exactly one element. The user can also extend RichMapFunction to gain access to other features provided by the RichFunction interface.
    
    Type Parameters:
    R - output type
    Parameters:
    mapper - The MapFunction that is called for each element of the DataStream.
    
    Returns:
    The transformed DataStream.
  - flatMap
```
public <R> SingleOutputStreamOperator<R> flatMap(FlatMapFunction<T,R> flatMapper)
```
    Applies a FlatMap transformation on a DataStream. The transformation calls a FlatMapFunction for each element of the DataStream. Each FlatMapFunction call can return any number of elements including none. The user can also extend RichFlatMapFunction to gain access to other features provided by the RichFunction interface.
    
    Type Parameters:
    R - output type
    Parameters:
    flatMapper - The FlatMapFunction that is called for each element of the DataStream
    
    Returns:
    The transformed DataStream.
  - filter
```
public SingleOutputStreamOperator<T> filter(FilterFunction<T> filter)
```
    Applies a Filter transformation on a DataStream. The transformation calls a FilterFunction for each element of the DataStream and retains only those element for which the function returns true. Elements for which the function returns false are filtered. The user can also extend RichFilterFunction to gain access to other features provided by the RichFunction interface.
    
    Parameters:
    filter - The FilterFunction that is called for each element of the DataStream.
    
    Returns:
    The filtered DataStream.
  - project
```
@PublicEvolving
public <R extends Tuple> SingleOutputStreamOperator<R> project(int... fieldIndexes)
```
    Initiates a Project transformation on a Tuple DataStream.
    Note: Only Tuple DataStreams can be projected.
    The transformation projects each Tuple of the DataSet onto a (sub)set of fields.
    
    Parameters:
    fieldIndexes - The field indexes of the input tuples that are retained. The order of fields in the output tuple corresponds to the order of field indexes.
    
    Returns:
    The projected DataStream
    See Also:
    Tuple, DataStream
  - coGroup
```
public <T2> CoGroupedStreams<T,T2> coGroup(DataStream<T2> otherStream)
```
    Creates a join operation. See CoGroupedStreams for an example of how the keys and window can be specified.
  - join
```
public <T2> JoinedStreams<T,T2> join(DataStream<T2> otherStream)
```
    Creates a join operation. See JoinedStreams for an example of how the keys and window can be specified.
  - timeWindowAll
```
public AllWindowedStream<T,TimeWindow> timeWindowAll(Time size)
```
    Windows this DataStream into tumbling time windows.
    This is a shortcut for either .window(TumblingEventTimeWindows.of(size)) or .window(TumblingProcessingTimeWindows.of(size)) depending on the time characteristic set using
    Note: This operation can be inherently non-parallel since all elements have to pass through the same operator instance. (Only for special cases, such as aligned time windows is it possible to perform this operation in parallel). StreamExecutionEnvironment.setStreamTimeCharacteristic(org.apache.flink.streaming.api.TimeCharacteristic)
    
    Parameters:
    size - The size of the window.
  - timeWindowAll
```
public AllWindowedStream<T,TimeWindow> timeWindowAll(Time size,
                                            Time slide)
```
    Windows this DataStream into sliding time windows.
    This is a shortcut for either .window(SlidingEventTimeWindows.of(size, slide)) or .window(SlidingProcessingTimeWindows.of(size, slide)) depending on the time characteristic set using StreamExecutionEnvironment.setStreamTimeCharacteristic(org.apache.flink.streaming.api.TimeCharacteristic)
    Note: This operation can be inherently non-parallel since all elements have to pass through the same operator instance. (Only for special cases, such as aligned time windows is it possible to perform this operation in parallel).
    
    Parameters:
    size - The size of the window.
  - countWindowAll
```
public AllWindowedStream<T,GlobalWindow> countWindowAll(long size)
```
    Windows this DataStream into tumbling count windows.
    Note: This operation can be inherently non-parallel since all elements have to pass through the same operator instance. (Only for special cases, such as aligned time windows is it possible to perform this operation in parallel).
    
    Parameters:
    size - The size of the windows in number of elements.
  - countWindowAll
```
public AllWindowedStream<T,GlobalWindow> countWindowAll(long size,
                                               long slide)
```
    Windows this DataStream into sliding count windows.
    Note: This operation can be inherently non-parallel since all elements have to pass through the same operator instance. (Only for special cases, such as aligned time windows is it possible to perform this operation in parallel).
    
    Parameters:
    size - The size of the windows in number of elements.
    slide - The slide interval in number of elements.
  - windowAll
```
@PublicEvolving
public <W extends Window> AllWindowedStream<T,W> windowAll(WindowAssigner<? super T,W> assigner)
```
    Windows this data stream to a KeyedTriggerWindowDataStream, which evaluates windows over a key grouped stream. Elements are put into windows by a WindowAssigner. The grouping of elements is done both by key and by window.
    A Trigger can be defined to specify when windows are evaluated. However, WindowAssigners have a default Trigger that is used if a Trigger is not specified.
    Note: This operation can be inherently non-parallel since all elements have to pass through the same operator instance. (Only for special cases, such as aligned time windows is it possible to perform this operation in parallel).
    
    Parameters:
    assigner - The WindowAssigner that assigns elements to windows.
    
    Returns:
    The trigger windows data stream.
  - assignTimestamps
```
@Deprecated
public SingleOutputStreamOperator<T> assignTimestamps(TimestampExtractor<T> extractor)
```
    Deprecated. Please use assignTimestampsAndWatermarks(AssignerWithPeriodicWatermarks) of assignTimestampsAndWatermarks(AssignerWithPunctuatedWatermarks) instread.
    
    Extracts a timestamp from an element and assigns it as the internal timestamp of that element. The internal timestamps are, for example, used to to event-time window operations.
    If you know that the timestamps are strictly increasing you can use an AscendingTimestampExtractor. Otherwise, you should provide a TimestampExtractor that also implements TimestampExtractor.getCurrentWatermark() to keep track of watermarks.
    
    Parameters:
    extractor - The TimestampExtractor that is called for each element of the DataStream.
    See Also:
    assignTimestampsAndWatermarks(AssignerWithPeriodicWatermarks), assignTimestampsAndWatermarks(AssignerWithPunctuatedWatermarks)
  - assignTimestampsAndWatermarks
```
public SingleOutputStreamOperator<T> assignTimestampsAndWatermarks(AssignerWithPeriodicWatermarks<T> timestampAndWatermarkAssigner)
```
    Assigns timestamps to the elements in the data stream and periodically creates watermarks to signal event time progress.
    This method creates watermarks periodically (for example every second), based on the watermarks indicated by the given watermark generator. Even when no new elements in the stream arrive, the given watermark generator will be periodically checked for new watermarks. The interval in which watermarks are generated is defined in ExecutionConfig.setAutoWatermarkInterval(long).
    Use this method for the common cases, where some characteristic over all elements should generate the watermarks, or where watermarks are simply trailing behind the wall clock time by a certain amount.
    For cases where watermarks should be created in an irregular fashion, for example based on certain markers that some element carry, use the AssignerWithPunctuatedWatermarks.
    
    Parameters:
    timestampAndWatermarkAssigner - The implementation of the timestamp assigner and watermark generator.
    
    Returns:
    The stream after the transformation, with assigned timestamps and watermarks.
    See Also:
    AssignerWithPeriodicWatermarks, AssignerWithPunctuatedWatermarks, assignTimestampsAndWatermarks(AssignerWithPunctuatedWatermarks)
  - assignTimestampsAndWatermarks
```
public SingleOutputStreamOperator<T> assignTimestampsAndWatermarks(AssignerWithPunctuatedWatermarks<T> timestampAndWatermarkAssigner)
```
    Assigns timestamps to the elements in the data stream and periodically creates watermarks to signal event time progress.
    This method creates watermarks based purely on stream elements. For each element that is handled via TimestampAssigner.extractTimestamp(Object, long), the AssignerWithPunctuatedWatermarks.checkAndGetNextWatermark(Object, long) method is called, and a new watermark is emitted, if the returned watermark value is non-negative and greater than the previous watermark.
    This method is useful when the data stream embeds watermark elements, or certain elements carry a marker that can be used to determine the current event time watermark. This operation gives the programmer full control over the watermark generation. Users should be aware that too aggressive watermark generation (i.e., generating hundreds of watermarks every second) can cost some performance.
    For cases where watermarks should be created in a regular fashion, for example every x milliseconds, use the AssignerWithPeriodicWatermarks.
    
    Parameters:
    timestampAndWatermarkAssigner - The implementation of the timestamp assigner and watermark generator.
    
    Returns:
    The stream after the transformation, with assigned timestamps and watermarks.
    See Also:
    AssignerWithPunctuatedWatermarks, AssignerWithPeriodicWatermarks, assignTimestampsAndWatermarks(AssignerWithPeriodicWatermarks)
  - print
```
@PublicEvolving
public DataStreamSink<T> print()
```
    Writes a DataStream to the standard output stream (stdout).
    For each element of the DataStream the result of Object.toString() is written.
    
    Returns:
    The closed DataStream.
  - printToErr
```
@PublicEvolving
public DataStreamSink<T> printToErr()
```
    Writes a DataStream to the standard output stream (stderr).
    For each element of the DataStream the result of Object.toString() is written.
    
    Returns:
    The closed DataStream.
  - writeAsText
```
@PublicEvolving
public DataStreamSink<T> writeAsText(String path)
```
    Writes a DataStream to the file specified by path in text format.
    For every element of the DataStream the result of Object.toString() is written.
    
    Parameters:
    path - The path pointing to the location the text file is written to.
    
    Returns:
    The closed DataStream.
  - writeAsText
```
@PublicEvolving
public DataStreamSink<T> writeAsText(String path,
                                           FileSystem.WriteMode writeMode)
```
    Writes a DataStream to the file specified by path in text format.
    For every element of the DataStream the result of Object.toString() is written.
    
    Parameters:
    path - The path pointing to the location the text file is written to
    writeMode - Controls the behavior for existing files. Options are NO_OVERWRITE and OVERWRITE.
    
    Returns:
    The closed DataStream.
  - writeAsCsv
```
@PublicEvolving
public DataStreamSink<T> writeAsCsv(String path)
```
    Writes a DataStream to the file specified by the path parameter.
    For every field of an element of the DataStream the result of Object.toString() is written. This method can only be used on data streams of tuples.
    
    Parameters:
    path - the path pointing to the location the text file is written to
    
    Returns:
    the closed DataStream
  - writeAsCsv
```
@PublicEvolving
public DataStreamSink<T> writeAsCsv(String path,
                                          FileSystem.WriteMode writeMode)
```
    Writes a DataStream to the file specified by the path parameter.
    For every field of an element of the DataStream the result of Object.toString() is written. This method can only be used on data streams of tuples.
    
    Parameters:
    path - the path pointing to the location the text file is written to
    writeMode - Controls the behavior for existing files. Options are NO_OVERWRITE and OVERWRITE.
    
    Returns:
    the closed DataStream
  - writeAsCsv
```
@PublicEvolving
public <X extends Tuple> DataStreamSink<T> writeAsCsv(String path,
                                                            FileSystem.WriteMode writeMode,
                                                            String rowDelimiter,
                                                            String fieldDelimiter)
```
    Writes a DataStream to the file specified by the path parameter. The writing is performed periodically every millis milliseconds.
    For every field of an element of the DataStream the result of Object.toString() is written. This method can only be used on data streams of tuples.
    
    Parameters:
    path - the path pointing to the location the text file is written to
    writeMode - Controls the behavior for existing files. Options are NO_OVERWRITE and OVERWRITE.
    rowDelimiter - the delimiter for two rows
    fieldDelimiter - the delimiter for two fields
    
    Returns:
    the closed DataStream
  - writeToSocket
```
@PublicEvolving
public DataStreamSink<T> writeToSocket(String hostName,
                                             int port,
                                             SerializationSchema<T> schema)
```
    Writes the DataStream to a socket as a byte array. The format of the output is specified by a SerializationSchema.
    
    Parameters:
    hostName - host of the socket
    port - port of the socket
    schema - schema for serialization
    
    Returns:
    the closed DataStream
  - writeUsingOutputFormat
```
@PublicEvolving
public DataStreamSink<T> writeUsingOutputFormat(OutputFormat<T> format)
```
    Writes the dataStream into an output, described by an OutputFormat. The output is not participating in Flink's checkpointing! For writing to a file system periodically, the use of the "flink-connector-filesystem" is recommended.
    
    Parameters:
    format - The output format
    
    Returns:
    The closed DataStream
  - transform
```
@PublicEvolving
public <R> SingleOutputStreamOperator<R> transform(String operatorName,
                                                         TypeInformation<R> outTypeInfo,
                                                         OneInputStreamOperator<T,R> operator)
```
    Method for passing user defined operators along with the type information that will transform the DataStream.
    
    Type Parameters:
    R - type of the return stream
    Parameters:
    operatorName - name of the operator, for logging purposes
    outTypeInfo - the output type of the operator
    operator - the object containing the transformation logic
    
    Returns:
    the data stream constructed
  - setConnectionType
```
protected DataStream<T> setConnectionType(StreamPartitioner<T> partitioner)
```
    Internal function for setting the partitioner for the DataStream
    
    Parameters:
    partitioner - Partitioner to set.
    
    Returns:
    The modified DataStream.
  - addSink
```
public DataStreamSink<T> addSink(SinkFunction<T> sinkFunction)
```
    Adds the given sink to this DataStream. Only streams with sinks added will be executed once the StreamExecutionEnvironment.execute() method is called.
    
    Parameters:
    sinkFunction - The object containing the sink's invoke function.
    
    Returns:
    The closed DataStream.
  - getTransformation
```
@Internal
public StreamTransformation<T> getTransformation()
```
    Returns the StreamTransformation that represents the operation that logically creates this DataStream.
    
    Returns:
    The Transformation

Class DataStream<T>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

environment

transformation

Constructor Detail

DataStream

Method Detail

getId

getParallelism

getType

clean

getExecutionEnvironment

getExecutionConfig

union

split

connect

keyBy

keyBy

keyBy

partitionCustom

partitionCustom

partitionCustom

broadcast

shuffle

forward

rebalance

rescale

global

iterate

iterate

map

flatMap

filter

project

coGroup

join

timeWindowAll

timeWindowAll

countWindowAll

countWindowAll

windowAll

assignTimestamps

assignTimestampsAndWatermarks

assignTimestampsAndWatermarks

print

printToErr

writeAsText

writeAsText

writeAsCsv

writeAsCsv

writeAsCsv

writeToSocket

writeUsingOutputFormat

transform

setConnectionType

addSink

getTransformation