Java二维数组随机位置终止遍历的取值异常问题排查

云上老周

2026-8-26

问题根因排查

你遇到的三类异常全部来自循环逻辑和随机数生成的写法错误，对应关系如下：

数值无法正常传递、偶发循环不执行：你定义的二维数组wert第一维总长度只有100（合法下标范围0_{99），但外层循环初始化和迭代时用`rand.nextInt(200)`生成0}199的随机数，一旦第一次生成的i大于100，循环直接不执行，value1/value2/value3会保留初始值777；如果i大于99还会触发数组下标越界，直接中断程序。
第二维取值始终为0、无随机性：内层循环判断条件j < rand.nextInt(2)每次循环判定时都会重新生成随机数，rand.nextInt(2)只会返回0或1：返回0时j初始值为0，0<0不成立，内层循环直接不执行；返回1时j=0满足条件，执行一轮后j自增为1，下次判定重新生成随机数时大概率拿到0，循环终止，j永远没有机会取到1。
循环偶发不执行、重复打印：外层循环每次迭代都会重新给i赋0~199的随机值，没有固定的终止位置，会随机反复跳转i的值，只要随机到的i<=100就继续执行，可能出现无限重复输出，也可能第一次随机到i>100就直接退出；再叠加三段完全重复的冗余循环逻辑，进一步放大了执行混乱的问题。

正确实现方案

核心修正思路：提前生成合法范围内的固定随机终止位置，不要在循环判定条件里反复生成随机数，遍历到终止位置时直接跳出循环即可。

import java.util.Random;

public class RandomArrayTraverse {
    public static void main(String[] args) throws InterruptedException {
        int value1 = 777;
        int value2 = 777;
        int value3 = 777;

        int[][] wert = { { 0, 0 }, { 0, 1 }, { 0, 2 }, { 0, 3 }, { 0, 4 }, { 0, 5 }, { 0, 6 }, { 0, 7 },
                { 0, 8 }, { 0, 9 },
                { 1, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 }, { 1, 4 }, { 1, 5 }, { 1, 6 }, { 1, 7 },
                { 1, 8 }, { 1, 9 },
                { 2, 0 }, { 2, 1 }, { 2, 2 }, { 2, 3 }, { 2, 4 }, { 2, 5 }, { 2, 6 }, { 2, 7 },
                { 2, 8 }, { 2, 9 },
                { 3, 0 }, { 3, 1 }, { 3, 2 }, { 3, 3 }, { 3, 4 }, { 3, 5 }, { 3, 6 }, { 3, 7 },
                { 3, 8 }, { 3, 9 },
                { 4, 0 }, { 4, 1 }, { 4, 2 }, { 4, 3 }, { 4, 4 }, { 4, 5 }, { 4, 6 }, { 4, 7 },
                { 4, 8 }, { 4, 9 },
                { 5, 0 }, { 5, 1 }, { 5, 2 }, { 5, 3 }, { 5, 4 }, { 5, 5 }, { 5, 6 }, { 5, 7 },
                { 5, 8 }, { 5, 9 },
                { 6, 0 }, { 6, 1 }, { 6, 2 }, { 6, 3 }, { 6, 4 }, { 6, 5 }, { 6, 6 }, { 6, 7 },
                { 6, 8 }, { 6, 9 },
                { 7, 0 }, { 7, 1 }, { 7, 2 }, { 7, 3 }, { 7, 4 }, { 7, 5 }, { 7, 6 }, { 7, 7 },
                { 7, 8 }, { 7, 9 },
                { 8, 0 }, { 8, 1 }, { 8, 2 }, { 8, 3 }, { 8, 4 }, { 8, 5 }, { 8, 6 }, { 8, 7 },
                { 8, 8 }, { 8, 9 },
                { 9, 0 }, { 9, 1 }, { 9, 2 }, { 9, 3 }, { 9, 4 }, { 9, 5 }, { 9, 6 }, { 9, 7 },
                { 9, 8 }, { 9, 9 }, };
        Random rand = new Random();

        // 提前生成3组合法范围内的固定随机终止坐标
        int[] endPos1 = {rand.nextInt(wert.length), rand.nextInt(2)};
        int[] endPos2 = {rand.nextInt(wert.length), rand.nextInt(2)};
        int[] endPos3 = {rand.nextInt(wert.length), rand.nextInt(2)};

        // 第一组遍历，到指定终止位置停止
        outer1:
        for (int i = 0; i < wert.length; i++) {
            for (int j = 0; j < wert[i].length; j++) {
                value1 = wert[i][j];
                System.out.println("i: " + i);
                System.out.println("j: " + j);
                System.out.println("value1 " + value1);
                System.out.println("  ");
                if (i == endPos1[0] && j == endPos1[1]) {
                    break outer1;
                }
            }
        }

        // 第二组遍历，到指定终止位置停止
        outer2:
        for (int i = 0; i < wert.length; i++) {
            for (int j = 0; j < wert[i].length; j++) {
                value2 = wert[i][j];
                System.out.println("i: " + i);
                System.out.println("j: " + j);
                System.out.println("value2 " + value2);
                System.out.println("  ");
                if (i == endPos2[0] && j == endPos2[1]) {
                    break outer2;
                }
            }
        }

        // 第三组遍历，到指定终止位置停止
        outer3:
        for (int i = 0; i < wert.length; i++) {
            for (int j = 0; j < wert[i].length; j++) {
                value3 = wert[i][j];
                System.out.println("i: " + i);
                System.out.println("j: " + j);
                System.out.println("value3 " + value3);
                System.out.println("  ");
                if (i == endPos3[0] && j == endPos3[1]) {
                    break outer3;
                }
            }
        }

        System.out.println(value1 + " " + value2 + " " + value3);
        Thread.sleep(300);
    }
}

修正后的代码不会出现数组越界问题，第二维下标可以正常随机取0或1，循环执行逻辑稳定，既不会出现初始值残留，也不会出现无意义的重复输出，完全匹配遍历到随机位置终止的需求。

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