Cet article vous présentera comment implémenter la fonction des nombres répétitifs aléatoires en Java. Si vous êtes un débutant, il est nécessaire de lire cet article, car cette fonctionnalité sera généralement rencontrée lors des entretiens. Y compris lorsque je recrute des gens, j'aime aussi poser des autres sur cette question, principalement pour voir comment le modèle et les connaissances de base du problème sont considérés.
J'espère que cet article pourra aider des amis qui sont en contact pour la première fois, car j'ai contacté des amis qui ne peuvent pas l'écrire ou utiliser une façon très plate de penser pour y parvenir.
Généralement, des amis ayant une certaine expérience de développement peuvent mettre en œuvre de telles fonctions, mais ce n'est qu'une question d'efficacité. Lorsque nous sommes confrontés à de tels problèmes, nous y pensons toujours dans un ordre droit, puis ajoutons des nombres aléatoires au tableau dans une boucle. Dans le processus d'ajout de nombres, recherchez d'abord si ce nombre existe dans le tableau. Si ce nombre n'existe pas, il sera ajouté directement au tableau; Si ce nombre existe, il ne sera pas ajouté. Nous considérons généralement le problème de cette manière, et nous pouvons implémenter des fonctions de cette manière. Comme je l'ai dit, ce n'est qu'une question d'efficacité.
Afin de mieux comprendre la signification de cette question, examinons 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 les positions sont aléatoires, mais les éléments du tableau ne peuvent pas être répétés.
Ici, nous n'avons pas spécifié la longueur du tableau, nous pouvons faire une longueur entre 1 et 100.
Ensuite, jetons un coup d'œil à plusieurs méthodes de mise en œuvre et comparons ces méthodes .
Habituellement, nous utiliserons ArrayList ou Array pour l'implémenter. Examinons d'abord le processus d'implémentation de ArrayList, comme indiqué dans le code suivant:
Importer java.util.arraylist; Importer java.util.random; / ** * implémentation en utilisant ArrayList * @description: * @file: Demo.java * @package non * @author hanyonglu * @date 2012-10-18 06:16:55 PM * @version v1.0 * / public class Demo {public static vox Objet [] valeurs = nouvel objet [20]; Aléatoire aléatoire = nouveau aléatoire (); ArrayList <Integer> list = new ArrayList <Integer> (); pour (int i = 0; i <valeurs.length; i ++) {int if (! list.contains (numéro)) {list.add (numéro); }} valeurs = list.toArray (); // traverse le tableau et imprimez les données pour (int i = 0; i <valeurs.length; i ++) {System.out.print (valeurs [i] + "/ t"); if ((i + 1)% 10 == 0) {System.out.println ("/ n"); }}}} Le processus de mise en œuvre à l'aide de tableaux est le suivant:
Importer java.util.random; / ** * Implémentation Utilisation des tableaux * @Description: * @file: Demo4.java * @package non * @Author Hanyonglu * @Date 2012-10-18 06:27:38 PM * @version v1.0 * / public class Demo4 {public Static Vend Main (String [] args) {int [] Values = New int [20]; Aléatoire aléatoire = nouveau aléatoire (); pour (int i = 0; i <valeurs.length; i ++) {int pour (int j = 0; j <= i; j ++) {if (nombre! = valeurs [j]) {valeurs [i] = nombre; }}} // traverse le tableau et imprimez les données pour (int i = 0; i <valeurs.length; i ++) {System.out.print (valeurs [i] + "/ t"); if ((i + 1)% 10 == 0) {System.out.println ("/ n"); }}}} Les deux processus de mise en œuvre ci-dessus sont relativement inefficaces. Parce que chaque fois que vous ajoutez, vous devez traverser si ce nombre existe dans la liste actuelle, la complexité du temps est O (n ^ 2). Nous pouvons y penser de cette façon: comme il n'y a pas de duplication impliquée, nous pouvons penser aux fonctions de Hashset et Hashmap. HashSet implémente l'interface SET et la définition mathématique de l'ensemble est un ensemble sans duplication ni commande. Hashmap implémente la carte, et c'est aussi une clé qui ne permet pas de doublons. De cette façon, nous pouvons utiliser HashMap ou HashSet pour y parvenir.
Lorsque vous utilisez l'implémentation HashMap, il vous suffit de convertir sa clé en un tableau et ce sera OK, comme suit:
Importer java.util.hashmap; import java.util.iterator; import java.util.random; importer java.util.map.entry; / ** * implémentation en utilisant hashmap * @description: * @file: démo.java * @package non * @Author hanyonglu * @date 2012-10-18 06:12:50 pm * @version * @date 2012-18 V1.0 * / classe publique Demo {public static void main (String [] args) {int n = 0; Objet [] valeurs = nouvel objet [20]; Aléatoire aléatoire = nouveau aléatoire (); Hashmap <objet, objet> hashmap = new hashmap <objet, objet> (); // générer des nombres aléatoires et stocker hashmap pour (int i = 0; i <valeurs.length; i ++) {int numéro = random.nextint (100) + 1; hashmap.put (numéro, i); } // Importez des valeurs de tableau à partir de HashMap Values = hashmap.KeySet (). TOArray (); // traverse les données du tableau et de l'impression pour (int i = 0; i <valeurs.length; i ++) {System.out.print (valeurs [i] + "/ t"); if ((i + 1)% 10 == 0) {System.out.println ("/ n"); }} // iterator iter = hashmap.entryset (). Iterator (); // // traversal hashmap // while (iter.hasnext ()) {// entrée <Integer, entier> entrée = (entrée) iter.next (); // int key = entrée. "/ t"); // // if (n% 10 == 0) {// system.out.println ("/ n"); //} //}}} Étant donné que la relation entre hashset et hashmap est trop proche, HashSet est implémenté à l'aide de hashmap en bas, mais il n'y a pas de collection de valeur et une seule collection de clés, afin qu'elle puisse également être implémentée à l'aide de HashSet, comme suit:
Importer java.util.hashset; importer java.util.random; / ** * implémentation en utilisant hashset * @description: * @file: test.java * @package non * @author hanyonglu * @date 2012-10-18 06:11:41 pm * @version v1.0 * Aléatoire(); Objet [] valeurs = nouvel objet [20]; HashSet <Integer> HashSet = new HashSet <Integer> (); // Générez des nombres aléatoires et stockez HashSet pour (int i = 0; i <valeurs.length; i ++) {int hashset.add (numéro); } valeurs = hashSet.toArray (); // traverse les données du tableau et de l'impression pour (int i = 0; i <valeurs.length; i ++) {System.out.print (valeurs [i] + "/ t"); if ((i + 1)% 10 == 0) {System.out.println ("/ n"); }}}} C'est un peu plus efficace. Si nous avons limité la longueur du tableau, nous avons juste besoin de transformer la boucle FOR et de la définir en boucle whlie. Comme indiqué ci-dessous:
Importer java.util.hashset; importer java.util.random; / ** * implémentation en utilisant hashset * @description: * @file: test.java * @package non * @author hanyonglu * @date 2012-10-18 05:11:41 pm * @version v1.0 * / public test {public static natic nat Aléatoire(); Objet [] valeurs = nouvel objet [20]; HashSet <Integer> HashSet = new HashSet <Integer> (); // Générez des nombres aléatoires et du magasin Hashset While (hashSet.size () <valeurs.length) {hashSet.add (random.nextint (100) + 1); } valeurs = hashSet.toArray (); // traverse le tableau et imprimez les données pour (int i = 0; i <valeurs.length; i ++) {System.out.print (valeurs [i] + "/ t"); if ((i + 1)% 10 == 0) {System.out.println ("/ n"); }}}}Nous pouvons définir la longueur du tableau sur 100 et vérifier l'effet exécutif comme indiqué dans la figure ci-dessous:
Par rapport à ce qui précède, l'utilisation de hashmap est relativement efficace. En fait, il s'agit d'un hashset, d'un tableau et enfin d'une liste d'arrangement. Si nous générons 10000 données, nous constatons que l'utilisation de HashMap prend du temps: 0,05 s, le hashset est de 0,07 s, le tableau est de 0,20 et et ArrayList est de 0,25 s. Si vous êtes intéressé, vous pouvez définir l'heure pour le vérifier.
Bien sûr, en plus d'utiliser la mise en œuvre de HashMap, il existe d'autres méthodes efficaces. Par exemple, nous pouvons stocker les numéros 1-100 dans un tableau, puis générer au hasard deux indices dans la boucle pour. Si ces deux indices ne sont pas égaux, nous pouvons échanger des éléments dans le tableau. Le processus de mise en œuvre est le suivant:
Importer java.util.random; / ** * Implémentation de la conversion de position aléatoire * @Description: * @file: Demo4.java * @package non * @Author Hanyonglu * @Date 2012-10-18 06:54:06 PM * @version v1.0 * / public class Demo4 {public static Main (String [] args) {intres [] = neuf intatic-Void Main (String [String [] args) {intres [] = New Int]; int temp1, temp2, TEMP3; Random r = new Random (); pour (int i = 0; i <valeurs.length; i ++) {valeurs [i] = i + 1; } // Échange de valeurs au hasard // Générer au hasard une position temp2 = math.abs (r.Nextint ())% (valeurs.length-1); // Générez de manière aléatoire une autre position if (temp1! = Temp2) {TEMP3 = valeurs [temp1]; valeurs [temp1] = valeurs [temp2]; valeurs [temp2] = TEMP3; }} // traverse le tableau et imprimez les données pour (int i = 0; i <20; i ++) {System.out.print (valeurs [i] + "/ t"); if ((i + 1)% 10 == 0) {System.out.println ("/ n"); }}}} Cette méthode est également relativement efficace. Si 10 000 données sont générées, le temps nécessaire est de 0,054 s.
Sur la base de la mise en œuvre de coordonnées dans un tableau, des solutions plus liées peuvent être transformées et vous pouvez vous référer aux informations pertinentes en détail.
Ce qui précède consiste à mettre en œuvre la fonction des nombres aléatoires et non apétitifs en Java. Bien sûr, les méthodes ne se limitent pas à ces types, mais il existe d'autres méthodes de mise en œuvre. J'espère que cela sera utile aux amis qui sont en contact depuis un certain temps, et j'espère que cela pourra jouer un rôle dans l'attraction et l'attraction de Jade.
Site Web original: http://www.cnblogs.com/hanyonglu/archive/2012/10/18/2730007.html
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.