如何将扁平化后的IntStream还原为相邻元素配对的二维数组？

嘿，这个需求其实挺典型的——把流里的相邻元素两两配对成二维数组对吧？你提到想用flatMap，不过说实话flatMap是无状态的操作，不太适合直接处理这种需要记住“前一个元素”的场景，咱们换几个更合适的思路来实现：

方法一：用迭代器手动处理（最直观） #

这种方法逻辑清晰，容易理解，适合大多数串行流的场景：

// 假设我们的输入流是这个
IntStream inputStream = IntStream.of(1, 2, 3, 4);

PrimitiveIterator.OfInt iterator = inputStream.iterator();
List<int[]> resultList = new ArrayList<>();

// 先处理边界情况：空流直接返回空数组
if (!iterator.hasNext()) {
    int[][] finalArr = new int[0][];
    return finalArr;
}

// 初始化第一个元素作为"前一个值"
int prev = iterator.nextInt();
while (iterator.hasNext()) {
    int current = iterator.nextInt();
    // 把前一个和当前元素组成数组加入结果
    resultList.add(new int[]{prev, current});
    // 更新前一个值为当前元素，继续循环
    prev = current;
}

// 把List转成二维数组
int[][] finalArr = resultList.toArray(new int[0][]);

这个方法的好处是逻辑直白，不需要复杂的API，新手也能快速看懂，而且对各种输入情况（比如空流、单元素流）都能处理。

方法二：用自定义Holder类+Stream API实现 #

如果你更想用Stream的链式调用风格，可以用一个简单的Holder类来保存前一个元素的状态：

import java.util.Objects;
import java.util.stream.IntStream;

// 自定义一个Holder类来保存状态
class ElementHolder {
    int previous;
    boolean isInitialized;
}

public class Main {
    public static void main(String[] args) {
        IntStream inputStream = IntStream.of(1, 2, 3, 4);
        ElementHolder holder = new ElementHolder();

        int[][] finalArr = inputStream
                .mapToObj(current -> {
                    if (!holder.isInitialized) {
                        // 第一个元素只初始化holder，不生成数组
                        holder.previous = current;
                        holder.isInitialized = true;
                        return null;
                    } else {
                        // 生成配对数组，同时更新holder的前一个元素
                        int[] pair = new int[]{holder.previous, current};
                        holder.previous = current;
                        return pair;
                    }
                })
                .filter(Objects::nonNull) // 过滤掉第一个元素返回的null
                .toArray(int[][]::new);

        // 输出结果：{{1,2},{2,3},{3,4}}
        for (int[] arr : finalArr) {
            System.out.println("[" + arr[0] + "," + arr[1] + "]");
        }
    }
}

注意：这个方法只适合串行流，如果用并行流的话，Holder会被多个线程共享，导致状态混乱。如果需要并行处理，建议用下面的自定义Collector方法。

方法三：自定义Collector（支持并行流） #

如果你的流需要并行处理，可以自定义一个Collector来处理状态累积和合并：

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collector;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream inputStream = IntStream.of(1, 2, 3, 4);

        Collector<Integer, ?, int[][]> adjacentPairCollector = Collector.of(
                // 初始化累积器：第一个元素存前一个值，第二个存结果列表
                () -> new Object[]{null, new ArrayList<int[]>()},
                // 处理每个元素
                (acc, current) -> {
                    List<int[]> list = (List<int[]>) acc[1];
                    if (acc[0] == null) {
                        // 第一次处理，只保存当前元素为前一个值
                        acc[0] = current;
                    } else {
                        // 生成配对数组加入列表
                        list.add(new int[]{(int) acc[0], current});
                        // 更新前一个值
                        acc[0] = current;
                    }
                },
                // 并行流合并逻辑：把两个累积器的结果合并，还要处理第一个累积器的最后一个元素和第二个的第一个元素
                (acc1, acc2) -> {
                    List<int[]> list1 = (List<int[]>) acc1[1];
                    List<int[]> list2 = (List<int[]>) acc2[1];
                    // 如果两个累积器都有初始化的前一个值，需要把它们的边界元素配对
                    if (acc1[0] != null && acc2[0] != null) {
                        list1.add(new int[]{(int) acc1[0], (int) acc2[0]});
                    }
                    list1.addAll(list2);
                    // 返回合并后的累积器
                    acc1[0] = acc2[0] != null ? acc2[0] : acc1[0];
                    return acc1;
                },
                // 最终转换：把列表转成二维数组
                acc -> ((List<int[]>) acc[1]).toArray(new int[0][])
        );

        int[][] finalArr = inputStream.boxed().collect(adjacentPairCollector);
    }
}

这个方法稍微复杂一点，但支持并行处理，适合大数据量的场景。

为什么flatMap不太适合？ #

你提到想尝试flatMap，但flatMap的核心是把每个元素转换成一个新的流然后合并，它是无状态的——不会记住之前处理过的元素。而我们的需求需要“记住前一个元素”来配对，所以直接用flatMap很难实现，必须先把相邻元素配对成数组，再考虑是否需要flatMap，但配对的过程还是需要状态保存，所以不如上面的方法直接。

内容的提问来源于stack exchange，提问作者tarmogoyf