Comment générer des nombres aléatoires non répétitifs en Java

Générer des nombres aléatoires en Java

1. Appelez la méthode random() dans la classe Math sous java.lang pour générer des nombres aléatoires

Créer un nouveau fichier Pour les fichiers avec le suffixe java, le nom du fichier est MyRandom. Écrivez le code suivant dans cette classe :

public class MyRandom {
public static void main(String[] args) {
int radom = (int)(Math.random()*10);
System.out.println(radom);
}
}

Parmi eux, Math.random() //Génère une décimale aléatoire entre 0 et 1.

Génère un entier entre 0 et 9 comme : (int)(Math.random()*10);

Génère un entier entre 1 et 10 comme : (int)(Math.random) ()*10 + 1);

Et ainsi de suite : pour générer un nombre compris entre 0 et n, il faut l'écrire comme : Math.random()*n;

Obtenir un nombre aléatoire entier positif de longueur spécifiée :

public static int buildRandom(int length) {
int num = 1;
double random = Math.random();
if (random < 0.1) {
random = random + 0.1;
} for (int i = 0; i < length; i++) {
num = num * 10;
}
return (int) ((random * num));
}

2. Appelez la classe Random ci-dessous dans java.util. Les instances de cette classe sont utilisées pour générer un flux de nombres pseudo-aléatoires et génèrent un entier aléatoire, puis appelez. la méthode nextInt() de cette classe
Avant d'utiliser la classe Random, importez java.util.Random sous le package ; le code est :

import java.util.Random;
public class MyRandom {
public static void main(String[] args) {
Random rand = new Random();
int rInt = rand.nextInt(10);
System.out.println(rInt);
}
}

où Random rand = new Random() est créé Un nouveau générateur de nombres aléatoires ; rand.nextInt(int n) est une valeur int uniformément distribuée entre 0 (inclus) et la valeur spécifiée n (exclusive) tirée de la séquence de ce générateur de nombres aléatoires.

En Java, dans la classe de plage d'entiers spécifiée, la boucle génère différents nombres aléatoires

Pour générer 6 entiers aléatoires différents dans 20, par exemple :

public class MyRandom {
public static void main(String[] args) {
int n = 20;
Random rand = new Random();
boolean[] bool = new boolean[n];
int randInt = 0;
for(int i = 0; i < 6 ; i++) {
do {
randInt = rand.nextInt(n);
}while(bool[randInt]);
bool[randInt] = true;
System.out.println(randInt);
}
}
}

Un tableau de variables booléennes est utilisé pour stocker si le nombre est généré. Après génération, le nombre devient vrai en tant que valeur booléenne correspondante dans le tableau ci-dessous du tableau booléen. La prochaine fois que le nombre est généré, il entrera à nouveau dans la boucle do...while pour générer des nombres jusqu'à ce qu'un nombre qui n'a pas été généré. généré avant est généré.

Par exemple : générez un tableau de type int d'une longueur de 50 et insérez-y des nombres entre 0 et 50 de manière aléatoire, et ils ne peuvent pas être répétés.

Le code est le suivant :

public class MyRandom {
public static void main(String[] args) {
int[] intRandom = new int[50];
List mylist = new ArrayList(); //生成数据集，用来保存随即生成数，并用于判断
Random rd = new Random();
while(mylist.size() < 50) {
int num = rd.nextInt(51);
if(!mylist.contains(num)) {
mylist.add(num); //往集合里面添加数据。
}
}
for(int i = 0;i <mylist.size();i++) {
intRandom[i] = (Integer)(mylist.get(i));
}
}
}
/**
* 随机产生指定的范围不重复的集合
* @param size
* @return
*/
public static Set<Integer> generateRandomArray(int size){
Set<Integer> set = new LinkedHashSet<Integer>(); //集合是没有重复的值,LinkedHashSet是有顺序不重复集合,HashSet则为无顺序不重复集合
Integer num = size;
Integer range = size;
Random ran = new Random();
while(set.size() < num){
Integer tmp = ran.nextInt(range); //0-51之间随机选一个数
set.add(tmp);//直接加入，当有重复值时，不会往里加入，直到set的长度为52才结束
}
return set;
}

Pour plus de connaissances sur Java, veuillez faire attention à la colonne Tutoriel de base Java.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!