Java Stream API如何合并列表首元素处理与全列表操作

可以将两步操作合并，避免两次遍历列表的额外开销。你原有的实现会对testPojoList做两次遍历：第一次遍历到首元素就短路取数映射公司名，第二次全量遍历映射个人详情，实际上可以把逻辑整合，只做一次全量遍历就完成所有处理。

工程场景下优先选可读性高、性能无损失的写法，不需要强行把所有逻辑塞进Stream流水线里：

public void Mapping() {
    TestPojo testPojo1 = TestPojo.builder().name("Mike").city("Denver").company("Tesla").build();
    TestPojo testPojo2 = TestPojo.builder().name("Bob").city("Atlanta").company("Tesla").build();
    TestPojo testPojo3 = TestPojo.builder().name("Steve").city("Chicago").company("Tesla").build();
    TestPojo testPojo4 = TestPojo.builder().name("John").city("Boston").company("Tesla").build();

    List<TestPojo> testPojoList = Arrays.asList(testPojo1, testPojo2, testPojo3, testPojo4);

    // 单次流遍历，完成所有元素到PersonalDetails的映射
    List<PersonalDetails> personalDetailsList = testPojoList.stream()
            .map(this::mapOtherDetails)
            .collect(Collectors.toList());
    // 首元素直接通过下标O(1)获取，无额外遍历开销，和原逻辑对齐处理空列表场景
    TransformedTestPojo transformedTestPojo = testPojoList.isEmpty() 
            ? null 
            : mapCompanyName(testPojoList.get(0));
    
    if (transformedTestPojo != null) {
        transformedTestPojo.setPersonalDetailsList(personalDetailsList);
    }
    System.out.println(transformedTestPojo);
}

private PersonalDetails mapOtherDetails(TestPojo testPojo) {
    return PersonalDetails.builder().name(testPojo.getName()).City(testPojo.getCity()).build();
}

private TransformedTestPojo mapCompanyName(TestPojo testPojo) {
    return TransformedTestPojo.builder().company(testPojo.getCompany()).build();
}

这种写法的优势：

• 只做一次全量列表流遍历，性能比原两次流的实现更好
• 逻辑直白，没有冗余封装，后续维护成本低
• 完全对齐原有逻辑：空列表返回null，首元素映射公司名，全量元素映射详情列表

如果你要求所有逻辑都必须在单次Stream的collect阶段完成，不直接调用列表的get方法，可以用自定义收集容器的方式实现，全程只通过流遍历一次：

public void Mapping() {
    TestPojo testPojo1 = TestPojo.builder().name("Mike").city("Denver").company("Tesla").build();
    TestPojo testPojo2 = TestPojo.builder().name("Bob").city("Atlanta").company("Tesla").build();
    TestPojo testPojo3 = TestPojo.builder().name("Steve").city("Chicago").company("Tesla").build();
    TestPojo testPojo4 = TestPojo.builder().name("John").city("Boston").company("Tesla").build();

    List<TestPojo> testPojoList = Arrays.asList(testPojo1, testPojo2, testPojo3, testPojo4);

    // 自定义容器存中间结果：[0]存首元素映射的TransformedTestPojo，[1]存详情列表
    Object[] resultHolder = testPojoList.stream().collect(
            () -> new Object[]{null, new ArrayList<PersonalDetails>()},
            (container, pojo) -> {
                // 首次遇到元素时初始化TransformedTestPojo
                if (container[0] == null) {
                    container[0] = mapCompanyName(pojo);
                }
                // 每个元素都映射为PersonalDetails加入列表
                ((List<PersonalDetails>) container[1]).add(mapOtherDetails(pojo));
            },
            // 并行流合并分片结果的逻辑，顺序流不会触发
            (c1, c2) -> {
                if (c1[0] == null) {
                    c1[0] = c2[0];
                }
                ((List<PersonalDetails>) c1[1]).addAll((List<PersonalDetails>) c2[1]);
            }
    );

    TransformedTestPojo transformedTestPojo = (TransformedTestPojo) resultHolder[0];
    if (transformedTestPojo != null) {
        transformedTestPojo.setPersonalDetailsList((List<PersonalDetails>) resultHolder[1]);
    }
    System.out.println(transformedTestPojo);
}

这种写法的缺点是用Object数组做中间容器类型不够优雅，代码可读性比上一种实现差，除非有强制的编码规范要求，否则不推荐在业务代码里使用。

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