本文详解为何原始嵌套循环仅输出14次结果，并提供两种可靠解决方案：修复重置逻辑的嵌套循环与更简洁的单循环+模运算实现。

你遇到的问题非常典型——表面看是四层 while 循环，本应穷举 14⁴ = 38,416 种组合（每个 byte 元素取值 0 到 13），但实际只打印了 14 行，且全部集中在 [0, 0, 0, x]（x 从 0 到 13）。根本原因在于：内层循环变量未在每次外层迭代开始时重置为 0。

在你的原始代码中，moveSet[1]、moveSet[2] 和 moveSet[3] 一旦递增到 14 并退出对应 while 循环后，其值就永久停留在 14，后续外层循环再次进入时，内层条件（如 moveSet[1]

✅ 正确做法：每次进入某一层循环前，显式将所有内层索引重置为 0。修正后的嵌套结构如下：

public static void iterateThroughMoves() {
    byte[] moveSet = {0, 0, 0, 0};

    while (moveSet[0] < 14) {
        moveSet[1] = 0; // ← 关键：重置第2位
        while (moveSet[1] < 14) {
            moveSet[2] = 0; // ← 关键：重置第3位
            while (moveSet[2] < 14) {
                moveSet[3] = 0; // ← 关键：重置第4位
                while (moveSet[3] < 14) {
                    System.out.println(Arrays.toString(moveSet));
                    moveSet[3]++;
                }
                moveSet[2]++;
            }
            moveSet[1]++;
        }
        moveSet[0]++;
    }
}

⚠️ 注意事项：

• 重置语句必须放在对应 while 循环内部、紧邻循环条件之前（如 moveSet[1] = 0 放在 while (moveSet[1]
• byte 类型虽可表示 -128 到 127，但此处用作非负计数器（0–13）完全安全，无需担心溢出；
• 若数组长度动态变化（如支持 n 位组合），建议改用递归或迭代式进位算法，避免硬编码多层嵌套。

? 更优雅的替代方案：使用单层 for 循环 + 模运算，将四维组合映射为一维索引，代码更简洁、易扩展、无重置疏漏风险：

public static void iterateThroughMovesCompact() {
    int total = 14 * 14 * 14 * 14; // 38416
    for (int i = 0; i < total; i++) {
        byte[] moveSet = new byte[4];
        moveSet[3] = (byte) (i % 14);           // 个位（最低位）
        moveSet[2] = (byte) ((i / 14) % 14);    // 十位
        moveSet[1] = (byte) ((i / 14 / 14) % 14)
; // 百位
        moveSet[0] = (byte) ((i / 14 / 14 / 14) % 14); // 千位（最高位）
        System.out.println(Arrays.toString(moveSet));
    }
}

? 总结：嵌套循环的“重置”是初学者高频陷阱。记住口诀：外层每进一次，内层全归零。而模运算法本质是将 base-14 的四进制数逐位分解，兼具可读性与健壮性，推荐在组合枚举场景优先采用。