Je pense que le sens du hasard est que les deux valeurs de résultat sont imprévisibles. De manière générale, connaître A1 A2 ne peut pas déduire la signification de A3.
Le problème des valeurs répétées que vous avez évoquées doit être mesuré du point de vue de la probabilité. Si la probabilité d'obtenir chaque valeur est égale, cela signifie "aléatoire". Répéter les résultats deux fois ne signifie pas que ce n'est pas assez "aléatoire". .

Si vous devez strictement limiter les valeurs pour ne pas être répétées, vous devez disposer d'un lieu de stockage, et cette non-duplication doit également avoir une plage temporelle ou spatiale.

J'ai déjà vu un algorithme permettant de générer aléatoirement des nombres non répétitifs sur CSDN :

int startArray[] = {0,1,2,3,4,5,6,7,8,9};//seed array    
int N = 6;//随机数个数    
int resultArray[] = new int [N];//结果存放在里面    
for(int i = 0; i < N; i++)    
{    
    int seed = random(0, startArray.length - i);//从剩下的随机数里生成    
    resultArray[i] = startArray[seed];//赋值给结果数组    
    startArray[seed] = startArray[startArray.length - i - 1];//把随机数产生过的位置替换为未被选中的值。    
}  

Une méthode stupide consiste à initialiser directement le tableau, à placer chaque nombre dans la bonne position, puis à le sélectionner au hasard. Le premier résultat est échangé avec le dernier chiffre et le deuxième résultat est échangé avec l'avant-dernier chiffre. , après l'échange, une sélection aléatoire sera effectuée la prochaine fois. La plage du numéro sera également réduite de un en conséquence.

Quant à l'efficacité, l'affiche peut la mettre en œuvre.

public static void main(String[] args) {

    // 初始化数组
    int[] arr = new int[1000000];
    for (int i = 0; i < arr.length; i++) {
        arr[i] = i;
    }

    int randomCount = 1000;                         // 要生成多少个随机数
    Random random = new Random();                   // 随机数生成器
    long startTime = System.currentTimeMillis();    // 计时

    for (int i = 0; i < randomCount; i++) {
        // 随机挑选
        int pickIndex = random.nextInt(arr.length - i);

        // 交换
        int t = arr[pickIndex];
        arr[pickIndex] = arr[arr.length - 1 - i];
        arr[arr.length - 1 - i] = t;
    }

    System.out.println("take time: " + (System.currentTimeMillis() - startTime) + " ms");

    // 输出结果（超过一万就不输出了，直接看耗时）
    if (randomCount < 10000) {
        for (int i = 0; i < randomCount; i++) {
            System.out.printf("%06d ", arr[arr.length - i - 1]);
            if (i % 40 == 39) {
                System.out.println();
            }
        }
    }
}

Si le cycle de vie est long, 100 000 seront facilement épuisés. Après épuisement, il sera répétitif quelle que soit la façon dont vous le générez.

1. Le plus simple, Math.random()*10_0000, puis converti en int. Il n'y a aucune garantie qu'il ne sera pas répété

.

2. incrément, similaire à l'incrément de clé primaire de mysql À partir de 1, s'il y a moins de six chiffres, utilisez 0 pour compléter le front

.

3. Point avancé. Le nombre à six chiffres peut être combiné en utilisant divers facteurs d'influence. Bien sûr, ce nombre est relativement court et il n'y a pas beaucoup de facteurs à prendre en compte.

Enfin, donnez un lien de référence, la génération d'ID de système distribué. Cela n'est peut-être pas lié à votre problème, mais il a également une référence.

ThreadLocalRandom.current().ints(0, 100).distinct().limit(6).forEach(System.out::println);

0 à 100 est la plage, 6 est le nombre. Ce qui est plus important, c'est la sécurité des threads.