Généralement, des amis ayant une certaine expérience en développement peuvent réaliser une telle fonction, mais ce n'est qu'une question d'efficacité. Lorsque nous sommes habituellement confrontés à un tel problème, nous y pensons toujours dans un ordre plat. Commencez par générer un tableau, puis ajoutez des nombres aléatoires au tableau dans une boucle. Pendant le processus d'ajout de nombres, vérifiez d'abord s'ils existent dans le tableau. . Si ce numéro n'existe pas, il sera ajouté directement au tableau ; s'il existe, il ne sera pas ajouté. Nous envisageons généralement les problèmes de cette manière, et les fonctions peuvent être réalisées en pensant de cette manière, comme je l'ai dit tout à l'heure, c'est simplement une question d'efficacité.
Afin de mieux comprendre le sens de cette question, regardons d'abord le contenu spécifique : générer un tableau aléatoire de 1 à 100, mais les nombres du tableau ne peuvent pas être répétés, c'est-à-dire que la position est aléatoire, mais les éléments du tableau ne peut pas être répété. Ici, la longueur du tableau ne nous est pas spécifiée, nous pouvons la laisser entre 1 et 100.
Voyons ensuite comment mieux l'implémenter. Habituellement, nous utiliserons ArrayList pour l'implémenter, comme indiqué dans le code suivant :
Copiez le code comme suit :
paquet cn.sunzn.randomnumber ;
importer java.util.ArrayList ;
importer java.util.Random ;
Démo de classe publique {
public static void main (String[] arguments) {
Valeurs Object[] = new Object[20];
Aléatoire aléatoire = nouveau Aléatoire();
ArrayList<Integer> list = new ArrayList<Integer>();
pour (int i = 0; i < valeurs.longueur; i++) {
nombre int = random.nextInt(100) + 1 ;
si (!list.contains(number)) {
list.add(numéro);
}
}
valeurs = list.toArray();
/************ Parcourez le tableau et imprimez les données *************/
pour (int i = 0; i < valeurs.longueur; i++) {
System.out.print(values[i] + "/t");
si ((je + 1) % 10 == 0) {
System.out.println("/n");
}
}
}
}
Le processus de mise en œuvre ci-dessus est relativement inefficace. Parce que chaque fois que vous l'ajoutez, vous devez déterminer si le numéro existe dans la liste actuelle, la complexité temporelle est O(N^2). Nous pouvons y penser de cette façon : comme cela n’implique aucune duplication, nous pouvons penser aux fonctions de HashSet et de HashMap. HashSet implémente l'interface Set. La définition mathématique de Set est une collection sans duplication ni ordre. HashMap implémente Map et n'autorise pas les clés en double. De cette façon, nous pouvons utiliser HashMap ou HashSet pour y parvenir.
Lorsque vous utilisez HashMap pour l'implémenter, il vous suffit de convertir sa clé en tableau. Le code est le suivant :
Copiez le code comme suit :
paquet cn.sunzn.randomnumber ;
importer java.util.HashMap ;
importer java.util.Random ;
Démo de classe publique {
public static void main (String[] arguments) {
Valeurs Object[] = new Object[20];
Aléatoire aléatoire = nouveau Aléatoire();
HashMap<Object, Object> hashMap = new HashMap<Object, Object>();
/******* Générez des nombres aléatoires et stockez-les dans HashMap *******/
pour (int i = 0; i < valeurs.longueur; i++) {
nombre int = random.nextInt(100) + 1 ;
hashMap.put(nombre, je);
}
/************ Importer un tableau depuis HashMap************/
valeurs = hashMap.keySet().toArray();
/*********** Parcourez le tableau et imprimez les données *************/
pour (int i = 0; i < valeurs.longueur; i++) {
System.out.print(values[i] + "/t");
si ((je + 1) % 10 == 0) {
System.out.println("/n");
}
}
}
}
Étant donné que la relation entre HashSet et HashMap est trop étroite, HashSet est implémenté en utilisant HashMap au niveau de la couche inférieure. Cependant, il n'y a pas de collection de valeurs, seulement une collection de clés, il peut donc également être implémenté en utilisant HashSet. :
Copiez le code comme suit :
paquet cn.sunzn.randomnumber ;
importer java.util.HashSet ;
importer java.util.Random ;
Démo de classe publique {
public static void main (String[] arguments) {
Aléatoire aléatoire = nouveau Aléatoire();
Valeurs Object[] = new Object[20];
HashSet<Integer> hashSet = new HashSet<Integer>();
/******* Générez des nombres aléatoires et stockez-les dans HashSet *******/
pour (int i = 0; i < valeurs.longueur; i++) {
nombre int = random.nextInt(100) + 1 ;
hashSet.add(nombre);
}
valeurs = hashSet.toArray();
/************* Parcourez le tableau et imprimez les données **********/
pour (int i = 0; i < valeurs.longueur; i++) {
System.out.print(values[i] + "/t");
si ((je + 1) % 10 == 0) {
System.out.println("/n");
}
}
}
}
Cette implémentation est légèrement plus efficace. Si nous limitons la longueur du tableau, il nous suffit de modifier la boucle for et de la définir sur une boucle whlie. Comme indiqué ci-dessous :
Copiez le code comme suit :
paquet cn.sunzn.randomnumber ;
importer java.util.HashSet ;
importer java.util.Random ;
Démo de classe publique {
public static void main (String[] arguments) {
Aléatoire aléatoire = nouveau Aléatoire();
Valeurs Object[] = new Object[20];
HashSet<Integer> hashSet = new HashSet<Integer>();
/****** Générez des nombres aléatoires et stockez-les dans HashSet ******/
while (hashSet.size() < valeurs.longueur) {
hashSet.add(random.nextInt(100) + 1);
}
valeurs = hashSet.toArray();
/************ Parcourez le tableau et imprimez les données *************/
pour (int i = 0; i < valeurs.longueur; i++) {
System.out.print(values[i] + "/t");
si ((je + 1) % 10 == 0) {
System.out.println("/n");
}
}
}
}