Java实现transform方法按指定规则合并嵌套List为String列表

现有如下嵌套列表结构：

List<List<String>> source = List.of(
                List.of("a", "b"),
                List.of("A", "B", "C"),
                List.of("1", "2", "3", "4"));

其中source.size()取值随机，每个子列表的长度也为随机值。
需要实现算法将该嵌套列表转换为单个List<String>，元素拼接顺序需符合如下示例规则：

List<String> transform(List<List<String>> source) {
    // ... 实现逻辑 ...
    return List.of ("aA1", "aA2", "aA3", "aA4",
                    "aB1", "aB2", "aB3", "aB4",
                    "aC1", "aC2", "aC3", "aC4",
                    "bA1", "bA2", "bA3", "bA4",
                    "bB1", "bB2", "bB3", "bB4",
                    "bC1", "bC2", "bC3", "bC4");
}

需要实现上述transform方法，输出符合顺序要求的结果列表。

这个需求本质是计算所有子列表的笛卡尔积，顺序规则为：越靠前的子列表元素迭代优先级越低（值变化越慢），越靠后的子列表元素迭代优先级越高（值变化越快），和示例输出的顺序完全匹配。
下面给出兼容任意层数、任意子列表长度的通用迭代实现，无递归栈溢出风险：

import java.util.ArrayList;
import java.util.List;

public class ListTransformer {
    public static List<String> transform(List<List<String>> source) {
        List<String> result = new ArrayList<>();
        // 空输入直接返回空列表
        if (source == null || source.isEmpty()) {
            return result;
        }
        // 初始化结果集为第一个子列表的所有元素
        result.addAll(source.get(0));
        // 从第二个子列表开始逐轮做笛卡尔积拼接
        for (int i = 1; i < source.size(); i++) {
            List<String> currentSubList = source.get(i);
            List<String> temp = new ArrayList<>();
            for (String prefix : result) {
                for (String suffix : currentSubList) {
                    temp.add(prefix + suffix);
                }
            }
            result = temp;
        }
        return result;
    }

    // 测试验证
    public static void main(String[] args) {
        List<List<String>> testSource = List.of(
                List.of("a", "b"),
                List.of("A", "B", "C"),
                List.of("1", "2", "3", "4"));
        // 输出结果和题目示例完全一致
        System.out.println(transform(testSource));
    }
}

逻辑说明 #

• 逐轮迭代的实现方式会把上一轮生成的所有前缀字符串，和当前子列表的每个元素依次拼接，天然满足顺序要求：第一个子列表的元素最后变化，最后一个子列表的元素最先变化，完全匹配示例的输出顺序
• 自动兼容边界场景：输入为空、某个子列表为空时，会按照笛卡尔积的规则返回空列表，不会抛出空指针或索引越界异常
• 没有递归深度限制，哪怕输入包含上百个子列表也能正常运行

如果使用Java 8及以上版本，也可以用Stream API的reduce算子实现更简洁的版本，核心逻辑和迭代版完全一致：

import java.util.List;

public class ListTransformerStream {
    public static List<String> transform(List<List<String>> source) {
        return source.stream()
                .reduce((listA, listB) -> listA.stream()
                        .flatMap(prefix -> listB.stream().map(suffix -> prefix + suffix))
                        .toList())
                .orElseGet(List::of);
    }
}

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