如何降低六重笛卡尔积代码的认知复杂度？

我之前在项目里碰到过几乎一模一样的场景——多层嵌套循环直接触发了linter的认知复杂度告警，而且这种代码后续维护起来简直是噩梦，绝对不建议保留原始代码，必须重构。下面分享几个我实际用过、不需要依赖第三方库的可行方案：

方案一：拆分嵌套循环为多个独立方法 #

认知复杂度是针对单个方法计算的，我们可以把内层循环逐步拆分到单独的小方法里，让每个方法的嵌套层级控制在极低水平，这样单个方法的认知复杂度就能轻松降到阈值以下。

重构后的代码示例：

public void processAllItems(List<String> itemList1, List<String> itemList2, List<String> itemList3,
                            List<String> itemList4, List<String> itemList5, List<String> itemList6) {
    for (String item1 : itemList1) {
        processWithItem1(item1, itemList2, itemList3, itemList4, itemList5, itemList6);
    }
}

private void processWithItem1(String item1, List<String> itemList2, List<String> itemList3,
                              List<String> itemList4, List<String> itemList5, List<String> itemList6) {
    for (String item2 : itemList2) {
        processWithItem1And2(item1, item2, itemList3, itemList4, itemList5, itemList6);
    }
}

private void processWithItem1And2(String item1, String item2, List<String> itemList3,
                                  List<String> itemList4, List<String> itemList5, List<String> itemList6) {
    for (String item3 : itemList3) {
        processWithItem1To3(item1, item2, item3, itemList4, itemList5, itemList6);
    }
}

private void processWithItem1To3(String item1, String item2, String item3,
                                 List<String> itemList4, List<String> itemList5, List<String> itemList6) {
    for (String item4 : itemList4) {
        processWithItem1To4(item1, item2, item3, item4, itemList5, itemList6);
    }
}

private void processWithItem1To4(String item1, String item2, String item3, String item4,
                                 List<String> itemList5, List<String> itemList6) {
    for (String item5 : itemList5) {
        processWithItem1To5(item1, item2, item3, item4, item5, itemList6);
    }
}

private void processWithItem1To5(String item1, String item2, String item3, String item4, String item5,
                                 List<String> itemList6) {
    for (String item6 : itemList6) {
        methodToRun(item1, item2, item3, item4, item5, item6);
    }
}

每个方法最多只有1层循环，认知复杂度直接降到个位数，完全符合规范，而且每个方法的职责清晰，后续修改或排查问题都更方便。

方案二：手动实现笛卡尔积迭代 #

如果觉得拆分太多方法有点繁琐，可以把所有列表的组合转换成笛卡尔积，通过单一循环处理所有组合后的元素，从根源上消除多层嵌套。

示例代码：

public void processAllItems(List<List<String>> allItemLists) {
    List<List<String>> cartesianProduct = generateCartesianProduct(allItemLists);
    for (List<String> itemCombination : cartesianProduct) {
        methodToRun(itemCombination.get(0), itemCombination.get(1), itemCombination.get(2),
                    itemCombination.get(3), itemCombination.get(4), itemCombination.get(5));
    }
}

private List<List<String>> generateCartesianProduct(List<List<String>> lists) {
    List<List<String>> result = new ArrayList<>();
    if (lists.isEmpty()) {
        result.add(new ArrayList<>());
        return result;
    }
    // 递归生成剩余列表的笛卡尔积
    List<String> firstList = lists.get(0);
    List<List<String>> remainingProduct = generateCartesianProduct(lists.subList(1, lists.size()));
    // 组合当前列表元素与剩余组合
    for (String item : firstList) {
        for (List<String> remainingItems : remainingProduct) {
            List<String> combination = new ArrayList<>();
            combination.add(item);
            combination.addAll(remainingItems);
            result.add(combination);
        }
    }
    return result;
}

调用时只需传入所有列表：

processAllItems(Arrays.asList(itemList1, itemList2, itemList3, itemList4, itemList5, itemList6));

这个方案扩展性极强——以后新增itemList7，只需要修改调用处，不用再加循环，而且generateCartesianProduct的认知复杂度仅为5左右，完全符合要求。

方案三：使用Stream API链式处理（Java 8+） #

如果项目使用Java 8及以上版本，可以用Stream的flatMap逐层展开循环，把多层嵌套转换成链式调用，代码更简洁，认知复杂度也会大幅下降。

示例代码：

public void processAllItems(List<String> itemList1, List<String> itemList2, List<String> itemList3,
                            List<String> itemList4, List<String> itemList5, List<String> itemList6) {
    itemList1.stream()
            .flatMap(item1 -> itemList2.stream().map(item2 -> new Pair<>(item1, item2)))
            .flatMap(pair12 -> itemList3.stream().map(item3 -> new Triple<>(pair12.first, pair12.second, item3)))
            .flatMap(pair123 -> itemList4.stream().map(item4 -> new Quad<>(pair123.first, pair123.second, pair123.third, item4)))
            .flatMap(pair1234 -> itemList5.stream().map(item5 -> new Quint<>(pair1234.first, pair1234.second, pair1234.third, pair1234.fourth, item5)))
            .forEach(pair12345 -> itemList6.forEach(item6 -> 
                    methodToRun(pair12345.first, pair12345.second, pair12345.third,
                                pair12345.fourth, pair12345.fifth, item6)
            ));
}

// 定义简单的内部类存储中间组合
private static class Pair<A, B> {
    final A first;
    final B second;
    Pair(A first, B second) {
        this.first = first;
        this.second = second;
    }
}

private static class Triple<A, B, C> {
    final A first;
    final B second;
    final C third;
    Triple(A first, B second, C third) {
        this.first = first;
        this.second = second;
        this.third = third;
    }
}

// 同理实现Quad、Quint类，每个类多一个字段即可

这个方案没有多层嵌套结构，代码逻辑更线性，可读性比原始嵌套循环好很多，而且不需要依赖任何第三方库。

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