java流api-更改流<；列表<；配对<；A、 B>&燃气轮机&燃气轮机；配对<；列表<；A>；，列表<；B>&燃气轮机；

如何将

流

更改为

对

？ 我是通过以下方式做到这一点的：

1.使用

collect（Collectors.toList（））

收集

列表

结果

2.迭代列表结果，并将

A

s和

B

s添加到两个单独的列表中

3.创建新的

对

但我真的很怀疑在流中完成这件事。

---

我需要帮助。谢谢。

要在流本身中获得想要的结果，可以使用

reduce（）

：

取决于为什么要将其转换为流中的

对

编辑：请注意，使用第一个示例，您正在为初始流中的每个元素创建许多新的对象实例。这远远不是最佳解决方案。但是，如果您想在流中实现这一点，我看不到任何其他选项。
这是最简单的解决方案，但效果很好，我发现：

Pair<List<T1>, List<T2>> target = new Pair<>(
    pairStream.stream().map(i -> i.getT1()).collect(Collectors.toList()),
    pairStream.stream().map(i -> i.getT2()).collect(Collectors.toList())
);

配对目标=新配对(
pairStream.stream（）.map（i->i.getT1（））.collect（Collectors.toList（）），
pairStream.stream（）.map（i->i.getT2（））.collect（Collectors.toList（））
);

我假设类对有一个构造函数
公共对（T1 T1，t2t2）

我不知道任何解决方案能够使用单个流返回所需的结果

使用
collect（Collectors.toList（））
收集
列表
结果
您可以使用
collector.of（）
（在本例中javafx.util.Pair）编写自定义收集器：

“让我们看看你到目前为止都做了些什么？”拉文德拉兰瓦拉编辑。你把你不工作的代码放进去，这样我们就可以改进/修复它了，这让我很困惑？？OP想在流程中创建一对，正如你提到的，有点复杂，但可以工作，我想这是对
reduce
的滥用。将以平行流中断。我强烈推荐阅读和阅读。
    final Stream<Pair<A, B>> stream = // your stream

    final List<A> listA = new ArrayList<>();
    final List<B> listB = new ArrayList<>();

    stream.forEach(p -> {
        listA.add(p.getKey());
        listB.add(p.getValue());
    });

    final Pair<List<A>, List<B>> result = new Pair<>(listA, listB);

Pair<List<T1>, List<T2>> target = new Pair<>(
    pairStream.stream().map(i -> i.getT1()).collect(Collectors.toList()),
    pairStream.stream().map(i -> i.getT2()).collect(Collectors.toList())
);

  List<Pair<A, B>> pairs = // list of Pait
  Pair<List<A>,List<B>> pairOfLists = pairs.stream()
            .collect(
                    Collector.of(
                            //init accumulator
                            () -> new Pair<>(
                                     new ArrayList<>(),
                                     new ArrayList<>()
                            ), 
                            //processing each element
                            (pairOfLists, pair) -> {
                                pairOfLists.getKey().add(pair.getKey());
                                pairOfLists.getValue().add(pair.getValue());
                            },
                            //confluence of two accumulators in parallel execution
                            (pairOfLists1, pairOfLists2) ->{
                                pairOfLists1.getKey().addAll(pairOfLists2.getKey());
                                pairOfLists1.getValue()addAll(pairOfLists2.getValue());
                                return pairOfLists1;
                            }
                    )
            );

  Pair<List<A>, List<Integer>> p2 = p.stream()
            .collect(
                    () -> new Pair<>(
                            new ArrayList<>(),
                            new ArrayList<>()
                    ),
                    (pairOfLists, pair) -> {
                        pairOfLists.getKey().add(pair.getKey());
                        pairOfLists.getValue().add(pair.getValue());
                    },
                    (pairOfLists1, pairOfLists2) -> {
                        pairOfLists1.getKey().addAll(pairOfLists2.getKey());
                        pairOfLists1.getValue().addAll(pairOfLists2.getValue());
                    }
            );