java二维数组随机生成

可以使用Java的Random类和循环语句来随机生成二维数组。具体实现代码如下：

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        int[][] arr = new int[3][4]; // 定义一个3行4列的二维数组
        Random random = new Random(); // 创建Random对象
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = random.nextInt(100); // 生成0-99之间的随机数
                System.out.print(arr[i][j] + " "); // 输出数组元素
            }
            System.out.println(); // 换行
        }
    }
}

相关问题

二维数组随机生成地图迷宫_Java基于深度优先遍历的随机迷宫生成算法

生成迷宫的一种常见算法是基于深度优先遍历的随机迷宫生成算法。该算法的基本思路是从一个起始点出发，随机选择一个相邻的未被访问过的点，将其标记为已访问，并将两点之间的墙壁打通。然后以新访问的点为起点继续随机选择未访问过的点，直到所有的点都被访问过。

在Java中，可以使用二维数组表示迷宫地图。数组中的每个元素表示一个格子，可以包含四面墙壁状态的信息（例如用0表示墙壁存在，用1表示墙壁不存在），以及是否被访问过的信息（例如用0表示未被访问过，用1表示已被访问过）。以下是一个基于深度优先遍历的随机迷宫生成算法示例代码：

import java.util.Random;

public class MazeGenerator {

    private int width; // 迷宫宽度
    private int height; // 迷宫高度
    private int[][] maze; // 迷宫地图
    private Random random; // 随机数生成器

    // 构造函数
    public MazeGenerator(int width, int height) {
        this.width = width;
        this.height = height;
        maze = new int[height][width];
        random = new Random();
        generateMaze(0, 0); // 从左上角的格子开始生成迷宫
    }

    // 生成迷宫
    private void generateMaze(int row, int col) {
        maze[row][col] = 1; // 标记当前格子已访问过

        // 随机顺序访问邻居格子
        int[] directions = {0, 1, 2, 3}; // 上、右、下、左
        shuffle(directions); // 随机打乱顺序
        for (int direction : directions) {
            int newRow = row;
            int newCol = col;
            switch (direction) {
                case 0: // 上
                    newRow--;
                    break;
                case 1: // 右
                    newCol++;
                    break;
                case 2: // 下
                    newRow++;
                    break;
                case 3: // 左
                    newCol--;
                    break;
            }
            // 判断新格子是否在迷宫范围内且未被访问过
            if (newRow >= 0 && newRow < height && newCol >= 0 && newCol < width && maze[newRow][newCol] == 0) {
                // 打通两格之间的墙壁
                if (direction == 0) { // 上
                    maze[row][col] &= ~1; // 当前格子的上墙壁打通
                    maze[newRow][newCol] &= ~4; // 新格子的下墙壁打通
                } else if (direction == 1) { // 右
                    maze[row][col] &= ~2; // 当前格子的右墙壁打通
                    maze[newRow][newCol] &= ~8; // 新格子的左墙壁打通
                } else if (direction == 2) { // 下
                    maze[row][col] &= ~4; // 当前格子的下墙壁打通
                    maze[newRow][newCol] &= ~1; // 新格子的上墙壁打通
                } else if (direction == 3) { // 左
                    maze[row][col] &= ~8; // 当前格子的左墙壁打通
                    maze[newRow][newCol] &= ~2; // 新格子的右墙壁打通
                }
                generateMaze(newRow, newCol); // 递归访问新格子
            }
        }
    }

    // 随机打乱数组元素的顺序
    private void shuffle(int[] array) {
        for (int i = array.length - 1; i > 0; i--) {
            int j = random.nextInt(i + 1);
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }

    // 打印迷宫地图
    public void printMaze() {
        for (int i = 0; i < height; i++) {
            for (int j = 0; j < width; j++) {
                System.out.print(maze[i][j] + " ");
            }
            System.out.println();
        }
    }

    // 测试代码
    public static void main(String[] args) {
        MazeGenerator generator = new MazeGenerator(10, 10);
        generator.printMaze();
    }

}

运行上述代码，可以生成一个10x10的迷宫地图，并打印出来。你可以根据自己的需要修改迷宫大小，或者将迷宫地图保存为图片等。

用java 定义一个二维数组，生成随机数列并且值都小于100

在 Java 中，我们可以使用 `Random` 类来生成随机数，然后创建一个二维数组，并确保所有生成的数值都在指定范围内（例如小于100）。这里是一个示例：

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        int rows = 5; // 数组行数
        int cols = 10; // 数组列数
        int maxValue = 100; // 随机数的最大值

        // 创建一个 Random 对象
        Random random = new Random();

        // 初始化二维数组
        int[][] array = new int[rows][cols];

        // 为二维数组填充随机数
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                array[i][j] = random.nextInt(maxValue); // 使用nextInt()生成0到maxValue-1的随机整数
            }
        }

        // 打印数组
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }
}

在这个例子中，我们首先定义了数组的行数和列数，然后创建了一个 `Random` 实例。接着遍历数组，每次循环内部调用 `nextInt(maxValue)` 来获取一个介于0（含）到 `maxValue - 1`（不含）之间的随机整数。

运行这个程序会得到一个大小为 `rows` x `cols` 的二维数组，其中所有元素都是小于100的随机整数。