如何用Lambda优化合并List中SomeObject的chunk字节数组？

你已经实现了两种合并List<SomeObject>中chunk字节数组的方法，确实可以用Lambda表达式让代码更简洁优雅，这里给你几种实用方案：

方案一：纯Stream链式写法（结合字节流收集） #

这种方式完全基于Stream API实现，把每个chunk转成字节对应的Int流，再通过自定义收集器写入字节输出流，最后转成目标数组：

public static byte[] buildArray(List<SomeObject> list) {
    return list.stream()
            .map(SomeObject::getChunk)
            .flatMapToInt(bytes -> Arrays.stream(bytes).map(b -> b & 0xFF))
            .collect(ByteArrayOutputStream::new, 
                     ByteArrayOutputStream::write, 
                     (baos1, baos2) -> {
                         try {
                             baos1.write(baos2.toByteArray());
                         } catch (IOException e) {
                             throw new UncheckedIOException(e);
                         }
                     })
            .toByteArray();
}

注意：byte转int时加b & 0xFF是为了避免负数字节被扩展为32位负整数，保证最终字节值的正确性；同时把受检IO异常包装成UncheckedIOException，避免破坏Stream的链式简洁性。

方案二：简化版ByteArrayOutputStream结合Lambda #

你之前的字节输出流实现可以进一步简化，用方法引用和异常包装优化代码：

public static byte[] buildArray(List<SomeObject> list) {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    list.stream()
        .map(SomeObject::getChunk)
        .forEach(bytes -> {
            try {
                baos.write(bytes);
            } catch (IOException e) {
                throw new RuntimeException("合并字节数组失败", e);
            }
        });
    return baos.toByteArray();
}

如果想更优雅，还可以把写入逻辑抽成工具方法，用方法引用替代Lambda：

private static void writeToStream(ByteArrayOutputStream baos, byte[] bytes) {
    try {
        baos.write(bytes);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}

public static byte[] buildArray(List<SomeObject> list) {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    list.stream()
        .map(SomeObject::getChunk)
        .forEach(baos::writeToStream);
    return baos.toByteArray();
}

方案三：高效预分配数组+Stream遍历拷贝 #

如果你想保留原方法预分配数组的高性能（避免字节输出流的扩容开销），可以用Stream计算总长度，再通过原子类跟踪拷贝位置：

public static byte[] buildArray(List<SomeObject> list) {
    int totalSize = list.stream()
                        .mapToInt(item -> item.getChunk().length)
                        .sum();
    byte[] allBytes = new byte[totalSize];
    AtomicInteger position = new AtomicInteger(0);
    list.stream()
        .map(SomeObject::getChunk)
        .forEach(bytes -> {
            System.arraycopy(bytes, 0, allBytes, position.get(), bytes.length);
            position.addAndGet(bytes.length);
        });
    return allBytes;
}

这里用AtomicInteger是因为Lambda中引用的变量需要是final或等效final类型，原子类可以安全地在Lambda中更新位置值。

各方案对比 #

• 方案一：纯函数式风格，代码简洁，但中间经过IntStream转换，性能略逊于直接拷贝。
• 方案二：保留了字节输出流的易用性，代码可读性高，适合大多数日常场景。
• 方案三：和你最初的循环方法性能接近，同时用Stream替代普通for循环，更贴合函数式编程风格。

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