未知层数的多层嵌套循环实现方案求助

这个问题我之前也踩过坑！动态层数的嵌套循环确实没法用硬编码的固定循环来实现，这里给你两种实用的解决思路，都是Java的实现方案：

递归是最容易想到的方式，每一层递归对应一个维度的循环，当递归到最后一层时，执行你需要的核心逻辑。

import java.util.Arrays;

public class DynamicRecursiveLoops {
    public static void main(String[] args) {
        int[] array = {2, 3, 2}; // 示例数组，对应3层循环，你可以替换成任意长度的数组
        processDynamicLoops(array, new int[array.length], 0);
    }

    // currentIndices：记录当前各层循环的索引值；depth：当前处理的循环层数
    private static void processDynamicLoops(int[] bounds, int[] currentIndices, int depth) {
        // 当处理到最后一层的下一层时，说明已经进入最内层，执行核心操作
        if (depth == bounds.length) {
            doSomething(currentIndices);
            return;
        }
        // 遍历当前层的所有可能索引值
        for (int i = 0; i < bounds[depth]; i++) {
            currentIndices[depth] = i;
            // 递归处理下一层循环
            processDynamicLoops(bounds, currentIndices, depth + 1);
        }
    }

    // 这里替换成你实际要执行的逻辑
    private static void doSomething(int[] indices) {
        System.out.println("当前索引组合：" + String.join(", ", Arrays.stream(indices).mapToObj(String::valueOf).toArray(String[]::new)));
    }
}

逻辑说明： #

• depth参数标记当前正在处理的循环层数，从0开始，直到等于数组长度时触发核心操作
• currentIndices数组用来跟踪每一层循环当前的索引值，方便在最内层获取所有维度的索引组合
• 如果你的数组长度很大（比如超过1000），递归可能会触发栈溢出，这时候可以考虑下面的迭代方案

用迭代的方式模拟多层循环的递进，通过数组跟踪各层索引的状态，适合处理数组长度较大的场景。

import java.util.Arrays;

public class DynamicIterativeLoops {
    public static void main(String[] args) {
        int[] array = {2, 3, 2};
        processDynamicLoopsIterative(array);
    }

    private static void processDynamicLoopsIterative(int[] bounds) {
        int totalLayers = bounds.length;
        if (totalLayers == 0) return; // 空数组直接返回

        int[] currentIndices = new int[totalLayers];
        Arrays.fill(currentIndices, 0); // 初始化所有层的索引为0

        while (true) {
            // 先执行最内层的核心操作
            doSomething(currentIndices);

            // 从最后一层开始，尝试递增索引
            int currentLayer = totalLayers - 1;
            while (currentLayer >= 0) {
                currentIndices[currentLayer]++;
                // 如果当前层索引还没到上限，就停止递进，继续执行下一次操作
                if (currentIndices[currentLayer] < bounds[currentLayer]) {
                    break;
                }
                // 当前层索引已达上限，重置为0，继续往前一层递增
                currentIndices[currentLayer] = 0;
                currentLayer--;
            }
            // 如果所有层都已经遍历完毕（currentLayer < 0），退出循环
            if (currentLayer < 0) {
                break;
            }
        }
    }

    // 这里替换成你实际要执行的逻辑
    private static void doSomething(int[] indices) {
        System.out.println("当前索引组合：" + String.join(", ", Arrays.stream(indices).mapToObj(String::valueOf).toArray(String[]::new)));
    }
}

逻辑说明： #

• 用currentIndices数组记录每一层的当前索引，初始全为0
• 每次先执行核心操作，然后从最后一层开始尝试递增索引：如果当前层索引没到上限，就继续下一轮操作；如果到了上限，就重置为0并往前一层递进
• 当所有层都递进完毕（currentLayer < 0），说明所有索引组合都遍历完成，退出循环

额外注意事项： #

• 如果数组中存在元素为0的情况，对应的循环层不会执行，核心操作也不会触发该层的任何组合
• 如果数组长度为0，直接跳过所有操作即可

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