Java教程：高效生成元素重复次数可控的随机矩阵

import java.util.Arrays;
import java.util.Random;

public class RandomMatrixGenerator {
    public static void main(String[] args) {
        int[][] mat = new int[4][4];
        Random r = new Random();

        // 尝试直接生成0-7的随机数，然后+1得到1-8
        for(int i = 0; i < 4; i++){
            for(int j = 0; j < 4; j++){
                mat[i][j] = r.nextInt(8) + 1; // 生成1到8的随机数
            }
        }

        for(int i=0; i<4; i++){
            System.out.println(Arrays.toString(mat[i]));
        }
    }
}

int[] data = {1, 2, 3, 4, 5, 6, 7, 8};

import java.util.Random;

public class ShuffleUtil {
    /**
     * 对给定的整数数组进行随机洗牌。
     * 使用Fisher-Yates洗牌算法。
     *
     * @param data 待洗牌的整数数组
     * @return 洗牌后的数组
     */
    public static int[] randomizeArray(int[] data) {
        Random r = new Random();
        // 从数组的最后一个元素开始向前遍历
        for (int i = data.length - 1; i > 0; i--) {
            // 生成一个0到i（包含i）之间的随机索引
            int randomIndexSwap = r.nextInt(i + 1);
            // 交换当前元素data[i]与随机选择的元素data[randomIndexSwap]
            int temp = data[randomIndexSwap];
            data[randomIndexSwap] = data[i];
            data[i] = temp;
        }
        return data;
    }
}

import java.util.Arrays;
import java.util.Random; // 确保导入Random类

public class ControlledRandomMatrix {

    public static void main(String[] args) {
        int[][] mat = new int[4][4];
        int[] baseElements = {1, 2, 3, 4, 5, 6, 7, 8}; // 基础元素1-8

        // 第一次洗牌，用于填充矩阵的前两行
        int[] shuffledData1 = randomizeArray(Arrays.copyOf(baseElements, baseElements.length)); // 复制一份进行洗牌

        // 填充矩阵的第0行和第1行
        // mat[0][j] = shuffledData1[j]
        // mat[1][j] = shuffledData1[4+j]
        for (int j = 0; j < 4; j++) {
            mat[0][j] = shuffledData1[j];
            mat[1][j] = shuffledData1[4 + j];
        }

        // 第二次洗牌，用于填充矩阵的后两行
        int[] shuffledData2 = randomizeArray(Arrays.copyOf(baseElements, baseElements.length)); // 再次复制并洗牌

        // 填充矩阵的第2行和第3行
        // mat[2][j] = shuffledData2[j]
        // mat[3][j] = shuffledData2[4+j]
        for (int j = 0; j < 4; j++) {
            mat[2][j] = shuffledData2[j];
            mat[3][j] = shuffledData2[4 + j];
        }

        // 打印生成的矩阵
        System.out.println("生成的随机矩阵：");
        for (int i = 0; i < 4; i++) {
            System.out.println(Arrays.toString(mat[i]));
        }
    }

    /**
     * 对给定的整数数组进行随机洗牌（Fisher-Yates算法）。
     *
     * @param data 待洗牌的整数数组
     * @return 洗牌后的数组
     */
    public static int[] randomizeArray(int[] data) {
        Random r = new Random();
        for (int i = data.length - 1; i > 0; i--) {
            int randomIndexSwap = r.nextInt(i + 1); // 0 到 i (包含)
            int temp = data[randomIndexSwap];
            data[randomIndexSwap] = data[i];
            data[i] = temp;
        }
        return data;
    }
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class ControlledRandomMatrixWithCollections {

    public static void main(String[] args) {
        int[][] mat = new int[4][4];
        List<Integer> baseElements = new ArrayList<>();
        for (int i = 1; i <= 8; i++) {
            baseElements.add(i);
        }

        // 第一次洗牌
        Collections.shuffle(baseElements);
        for (int j = 0; j < 4; j++) {
            mat[0][j] = baseElements.get(j);
            mat[1][j] = baseElements.get(4 + j);
        }

        // 第二次洗牌
        Collections.shuffle(baseElements); // 再次洗牌
        for (int j = 0; j < 4; j++) {
            mat[2][j] = baseElements.get(j);
            mat[3][j] = baseElements.get(4 + j);
        }

        System.out.println("使用Collections.shuffle生成的随机矩阵：");
        for (int i = 0; i < 4; i++) {
            System.out.println(Arrays.toString(mat[i]));
        }
    }
}

List<Integer> allElements = new ArrayList<>();
for (int num = min; num <= max; num++) {
    for (int k = 0; k < K; k++) {
        allElements.add(num);
    }
}
Collections.shuffle(allElements);

int index = 0;
for (int i = 0; i < N; i++) {
    for (int j = 0; j < M; j++) {
        matrix[i][j] = allElements.get(index++);
    }
}
// 确保 allElements.size() == N * M