转化算子（transform operator）将一个或多个DataStream转换为新的DataStream，如此下去可以将多个转换组合成复杂的数据流拓扑。

本节介绍了基本转换，应用这些转换的有效物理分区（partition），以及对Flink转换chain的深入介绍。

目录

• DataStream转换
• 物理分区
• 任务链和资源组

DataStream转换

• map
  DataStream→DataStream |
  读取一个元素并生成一个元素。例如，一个map函数，它将输入流的值加倍：

DataStream<Integer> dataStream = //...
dataStream.map(new MapFunction<Integer, Integer>() {
    @Override
    public Integer map(Integer value) throws Exception {
        return 2 * value;
    }
});

• FlatMap
  DataStream→DataStream
  读取一个元素，并生成零个、一个或多个元素。例如：将句子分割为单词的flatmap函数：

dataStream.flatMap(new FlatMapFunction<String, String>() {
    @Override
    public void flatMap(String value, Collector<String> out)
        throws Exception {
        for(String word: value.split(" ")){
            out.collect(word);
        }
    }
});

• Filter
  DataStream→DataStream
  将每个元素输入的filter布尔函数：仅保留filter函数返回true的那部分元素，filter返回false的元素会被过滤掉。例如：过滤掉零值的过滤器：

dataStream.filter(new FilterFunction<Integer>() {
    @Override
    public boolean filter(Integer value) throws Exception {
        return value != 0;
    }
});

• KeyBy
  DataStream→KeyedStream |

在逻辑上将流分区为互不相交的分区。具有相同key的所有记录会分配给到同一分区。在内部，keyBy（）是使用hash分区实现。在flink中有多种指定键的方法
此转换返回的是KeyedStream，其中包括key-state。

dataStream.keyBy("someKey") // Key by field "someKey"
dataStream.keyBy(0) // Key by the first element of a Tuple

注意 ：

1. 它是POJO类型，但不覆盖hashCode（）方法，key内部是hash分区依赖于hashCode（）方法的实现。
2. 任何类型的数组也不能成为key。

• reduce
  KeyedStream→DataStream

注意reduce函数是将KeyedStream转换为DataStream，也就是reduce调用前必须进行分区，即得先调用keyBy()函数

在分区的数据流上调用reduce函数：将当前元素与最后一个reduce的值合并生成新值。

例如：一个求和的reduce函数：

keyedStream.reduce(new ReduceFunction<Integer>() {
    @Override
    public Integer reduce(Integer value1, Integer value2)
    throws Exception {
        return value1 + value2;
    }
});

• Fold
  KeyedStream→DataStream
  注意Fold转换必须是基于KeyedStream（比如先执行keyBy操作）。

在一个初始值上进行Fold操作：将当前值和上一次Fold产生的值进行合并产生一个新的值：

比如：将Fold函数应用于（1,2,3,4,5）时，结果为：“start-1”，“start-1-2”，“start-1-2-3”,. ..

DataStream<String> result =
  keyedStream.fold("start", new FoldFunction<Integer, String>() {
    @Override
    public String fold(String current, Integer value) {
        return current + "-" + value;
    }
  });

• Aggregations（聚合）
  KeyedStream→DataStream
  min和minBy之间的差异是min返回最小值，而minBy返回该字段中具有最小值的元素（max和maxBy相同）。

keyedStream.sum(0);
keyedStream.sum("key");
keyedStream.min(0);
keyedStream.min("key");
keyedStream.max(0);
keyedStream.max("key");
keyedStream.minBy(0);
keyedStream.minBy("key");
keyedStream.maxBy(0);
keyedStream.maxBy("key");

• Window
  KeyedStream→WindowedStream

可以在已经分区的KeyedStream上定义Windows。Windows根据某些特征（例如，在最后5秒内到达的数据）对每个key中的数据进行分组。有关窗口的完整说明，请参见windows。

dataStream.keyBy(0).window(TumblingEventTimeWindows.of(Time.seconds(5))); // Last 5 seconds of data

• WindowAll
  DataStream→AllWindowedStream

Windows可以在常规DataStream上定义。Windows根据某些特征（例如，在最后5秒内到达的数据）对所有流事件进行分组。有关窗口的完整说明，请参见windows。

警告：在许多情况下，这是非并行转换。对于indowAll运算算子来说所有记录将收集在一个任务中。

dataStream.windowAll(TumblingEventTimeWindows.of(Time.seconds(5))); // Last 5 seconds of data

• Window Apply
  WindowedStream→DataStream
  AllWindowedStream→DataStream |

将一般性函数应用于整个窗口。下面是一个求和窗口函数。

注意：如果您正在使用windowAll转换，则需要使用AllWindowFunction。

windowedStream.apply (new WindowFunction<Tuple2<String,Integer>, Integer, Tuple, Window>() {
    public void apply (Tuple tuple,
            Window window,
            Iterable<Tuple2<String, Integer>> values,
            Collector<Integer> out) throws Exception {
        int sum = 0;
        for (value t: values) {
            sum += t.f1;
        }
        out.collect (new Integer(sum));
    }
});

// applying an AllWindowFunction on non-keyed window stream
allWindowedStream.apply (new AllWindowFunction<Tuple2<String,Integer>, Integer, Window>() {
    public void apply (Window window,
            Iterable<Tuple2<String, Integer>> values,
            Collector<Integer> out) throws Exception {
        int sum = 0;
        for (value t: values) {
            sum += t.f1;
        }
        out.collect (new Integer(sum));
    }
});

• Window Reduce
  WindowedStream→DataStream |

将reduce函数应用于窗口。返回reduce后的新结果。

windowedStream.reduce (new ReduceFunction<Tuple2<String,Integer>>() {
    public Tuple2<String, Integer> reduce(Tuple2<String, Integer> value1, Tuple2<String, Integer> value2) throws Exception {
        return new Tuple2<String,Integer>(value1.f0, value1.f1 + value2.f1);
    }
});

• Window Fold
  WindowedStream→DataStream

将fold函数应用于窗口并返回新的值。示例函数应用于序列（1,2,3,4,5）时，fold函数的输出为字符串“start-1-2-3-4-5”：

windowedStream.fold("start", new FoldFunction<Integer, String>() {
    public String fold(String current, Integer value) {
        return current + "-" + value;
    }
});

• Windows上的聚合
  WindowedStream→DataStream

聚合窗口上的内容。min和minBy之间的差异是：min返回最小值，而minBy返回该字段中具有最小值的元素（max和maxBy相同）。

windowedStream.sum(0);
windowedStream.sum("key");
windowedStream.min(0);
windowedStream.min("key");
windowedStream.max(0);
windowedStream.max("key");
windowedStream.minBy(0);
windowedStream.minBy("key");
windowedStream.maxBy(0);
windowedStream.maxBy("key");

• Union
  DataStream *→DataStream

两个或多个数据流的联合，创建包含来自所有流的所有元素的新流。注意：如果将数据流与其自身联合，则会在结果流中获取两次元素。

dataStream.union(otherStream1, otherStream2, ...);

• Window join
  DataStream，DataStream→DataStream |

在给定key和公共窗口上连接两个数据流。

dataStream.join(otherStream)
    .where(<key selector>).equalTo(<key selector>)
    .window(TumblingEventTimeWindows.of(Time.seconds(3)))
    .apply (new JoinFunction () {...});

• Window CoGroup
  DataStream，DataStream→DataStream |

在给定key和公共窗口上对两个数据流进行Cogroup。

dataStream.coGroup(otherStream)
    .where(0).equalTo(1)
    .window(TumblingEventTimeWindows.of(Time.seconds(3)))
    .apply (new CoGroupFunction () {...});

• Connect
  DataStream，DataStream→ConnectedStreams |

“连接”两个保留其类型的数据流。连接操作允许两个流之间的共享状态。

DataStream<Integer> someStream = //...
DataStream<String> otherStream = //...

ConnectedStreams<Integer, String> connectedStreams = someStream.connect(otherStream);

• CoMap，CoFlatMap
  ConnectedStreams→DataStream

类似于ConnectedStreams上的map和flatMap

connectedStreams.map(new CoMapFunction<Integer, String, Boolean>() {
    @Override
    public Boolean map1(Integer value) {
        return true;
    }

    @Override
    public Boolean map2(String value) {
        return false;
    }
});
connectedStreams.flatMap(new CoFlatMapFunction<Integer, String, String>() {

   @Override
   public void flatMap1(Integer value, Collector<String> out) {
       out.collect(value.toString());
   }

   @Override
   public void flatMap2(String value, Collector<String> out) {
       for (String word: value.split(" ")) {
         out.collect(word);
       }
   }
});

• Split
  DataStream→SplitStream

根据某些标准将流拆分为两个或更多个流。

SplitStream<Integer> split = someDataStream.split(new OutputSelector<Integer>() {
    @Override
    public Iterable<String> select(Integer value) {
        List<String> output = new ArrayList<String>();
        if (value % 2 == 0) {
            output.add("even");
        }
        else {
            output.add("odd");
        }
        return output;
    }
});

• Select
  SplitStream→DataStream

从split流中选择一个或多个流。

SplitStream<Integer> split;
DataStream<Integer> even = split.select("even");
DataStream<Integer> odd = split.select("odd");
DataStream<Integer> all = split.select("even","odd");

• 迭代
  DataStream→IterativeStream→DataStream |

通过将一个运算符的输出重定向到某个先前的运算符，在流中创建“反馈”循环。这对于定义不断更新模型的算法特别有用。以下代码以流开头并连续应用迭代体。大于0的元素将被发送回反馈通道，其余元素将向下游转发。有关完整说明，请参阅迭代。

IterativeStream<Long> iteration = initialStream.iterate();
DataStream<Long> iterationBody = iteration.map (/*do something*/);
DataStream<Long> feedback = iterationBody.filter(new FilterFunction<Long>(){
    @Override
    public boolean filter(Long value) throws Exception {
        return value > 0;
    }
});
iteration.closeWith(feedback);
DataStream<Long> output = iterationBody.filter(new FilterFunction<Long>(){
    @Override
    public boolean filter(Long value) throws Exception {
        return value <= 0;
    }
});

物理分区

Flink还通过以下函数对转换后的stream进行精确分区、进行low-level控制（如果需要）。

• 自定义分区
  DataStream→DataStream

使用用户定义的分区程序(Partitioner )为每个元素选择目标分区。

dataStream.partitionCustom(partitioner, "someKey");
dataStream.partitionCustom(partitioner, 0);

• 随机分区
  DataStream→DataStream
  均匀分布随机分配元素：（均匀分布）

dataStream.shuffle();

• 重新平衡（循环分区）
  DataStream→DataStream
  对元素循环分区，每个分区的负载相等。在存在数据偏斜时，用于性能优化。

dataStream.rebalance();