在 Java 开发中，笛卡尔积是指两个集合中任意元素两两组合形成的所有有序对。借助 Java 8 的流（Stream）特性，我们可以用更简洁的函数式代码替代传统的嵌套 for 循环来完成这一运算。
什么是集合的笛卡尔积
笛卡尔积来自数学概念，对于集合 A 与集合 B，其笛卡尔积 A×B 为所有形如 (a, b) 的有序对集合，其中 a 来自 A，b 来自 B。在编程中，这种运算常用于生成测试数据组合、配置矩阵、商品规格匹配等场景。
假设我们有两个 List，一个存放颜色，一个存放尺寸。我们希望得到颜色和尺寸的所有组合，传统方式需要两层循环，而使用 Java 8 流可以通过一次流水线表达清楚。理解笛卡尔积有助于我们判断何时该用流、何时该用普通循环。
传统循环写法与问题
在 Java 8 之前，计算两个集合的笛卡尔积通常写成嵌套循环，如下所示：
import java.util.ArrayList;
import java.util.List;
public class CartesianOld {
public static void main(String[] args) {
List<String> colors = List.of("红", "绿");
List<String> sizes = List.of("S", "M");
List<String> result = new ArrayList<>();
for (String c : colors) {
for (String s : sizes) {
result.add(c + "-" + s);
}
}
System.out.println(result);
}
}
这种写法直观，但存在几个问题。第一，代码层级随维度增加而增加，三个集合就要三层循环；第二，业务逻辑和遍历结构耦合，不利于并行化；第三，如果后续要对组合做过滤或映射，必须在循环体内继续堆代码。
当集合规模变大时，嵌套循环的性能瓶颈在于单线程执行。虽然可以手动改造为多线程，但代码复杂度会明显上升。流的引入正是为了解决这类问题。
使用 Java 8 流计算笛卡尔积
核心思路是利用 Stream 的 flatMap 方法。对于外层集合的每个元素，我们把它映射为一个内层集合的流，然后 flatMap 将这些流扁平化合并。配合 map 操作即可生成组合。
import java.util.List;
import java.util.stream.Collectors;
public class CartesianStream {
public static void main(String[] args) {
List<String> colors = List.of("红", "绿");
List<String> sizes = List.of("S", "M");
List<String> result = colors.stream()
.flatMap(c -> sizes.stream()
.map(s -> c + "-" + s))
.collect(Collectors.toList());
System.out.println(result);
}
}
上面的代码中，colors.stream() 产生外层流；flatMap 接收每个颜色 c，并返回 sizes.stream().map(s -> c + "-" + s) 这个内层流。flatMap 会把所有内层流连成一个完整的流，最后收集为列表。
这种写法语义清晰：外层遍历、内层映射、结果收集一目了然。如果需要增加第三个集合，只需再嵌套一层 flatMap，不会像循环那样产生缩进地狱。同时，流操作天然支持链式调用，可以在 collect 之前加入 filter、distinct 等中间操作。
并行流提升性能
当两个集合元素较多，比如各有上千条，组合总数会达到百万级。此时可以使用并行流利用多核 CPU：
import java.util.List;
import java.util.stream.Collectors;
public class CartesianParallel {
public static void main(String[] args) {
List<Integer> a = List.of(1, 2, 3, 4, 5);
List<Integer> b = List.of(10, 20, 30, 40, 50);
List<String> result = a.parallelStream()
.flatMap(x -> b.stream()
.map(y -> x + "," + y))
.collect(Collectors.toList());
System.out.println(result.size());
}
}
parallelStream 会把流拆分为多个子任务交给不同线程处理。在组合量大且单个映射逻辑较轻时，并行流通常能缩短执行时间。但要注意，如果组合后还要做重量级 IO 操作，线程竞争反而可能拖慢速度。
另一个注意点是线程安全。collect(Collectors.toList()) 在并行流下内部使用线程安全的容器，开发者无需手动加锁。但如果使用自定义的累加器，必须保证其具备线程安全特性，否则会出现数据丢失。
常见误区与优化建议
不少人在写流笛卡尔积时会把内层集合也转成并行流，形成平行嵌套并行，这会造成线程数爆炸且调度开销剧增。正确做法是只在外层使用 parallelStream，内层保持普通 stream。
此外，如果组合元素是高开销对象，建议先用基本类型或数组减少包装类创建。例如使用 IntStream 替代 List<Integer> 能避免 Integer 自动装箱。下面示例用原始 int 数组降低开销：
import java.util.Arrays;
public class CartesianInt {
public static void main(String[] args) {
int[] a = {1, 2, 3};
int[] b = {10, 20};
StringBuilder sb = new StringBuilder();
Arrays.stream(a)
.forEach(x -> Arrays.stream(b)
.forEach(y -> sb.append(x).append(",").append(y).append(" ")));
System.out.println(sb);
}
}
该写法虽然没用 collect，但展示了如何用数组流减少对象分配。实际项目中应结合业务权衡：函数式流带来可读性，原始循环带来极致性能，两者并非互斥。
最后提醒，当集合来自数据库或远程接口时，先确认数据量再决定是否在内存做笛卡尔积。超大集合的笛卡尔积会消耗大量内存，此时应考虑数据库层 JOIN 或分页流式处理，而不是一股脑加载到 List 里用流算。
小结
利用 Java 8 的 flatMap 可以优雅地实现两个集合的笛卡尔积，代码比嵌套循环更扁平、更易扩展。在适度数据量下，配合并行流还能提升吞吐。掌握流的惰性求值和收集机制，能让我们在实战中写出既清晰又高效的组合运算代码。