Résumé des méthodes Java pour générer des nombres aléatoires non répétitifs-JavaBase-php.cn

Résumé des méthodes Java pour générer des nombres aléatoires non répétitifs

Cet article vous présentera comment implémenter la fonction de nombres aléatoires non répétitifs en JAVA. (Cours vidéo associés recommandés : Tutoriel vidéo Java)

Afin de mieux comprendre le sens de cette question, jetons d'abord un coup d'œil au contenu spécifique : Générer un tableau aléatoire de 1- 100, mais le tableau Les nombres 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, la longueur du tableau ne nous est pas spécifiée, nous pouvons la laisser être n'importe quelle longueur comprise entre 1 et 100.

Examinons ensuite plusieurs méthodes de mise en œuvre et comparons-les.

Habituellement, nous utiliserons ArrayList ou un tableau pour l'implémenter. Examinons d'abord le processus d'implémentation d'ArrayList, comme indiqué dans le code suivant :

import java.util.ArrayList;
import java.util.Random;

/**
 * 使用ArrayList实现
 * @Description: 
 * @File: Demo.java
 * @Date 2012-10-18 下午06:16:55
 * @Version V1.0
 */
public class Demo {
    public static void main(String[] args) {
        Object[] values = new Object[20];
        Random random = new Random();
        ArrayList<Integer> list = new ArrayList<Integer>();

        for(int i = 0; i < values.length;i++){
            int number = random.nextInt(100) + 1;
            
            if(!list.contains(number)){
                list.add(number);
            }
        }
        
        values = list.toArray();
        
        // 遍历数组并打印数据
        for(int i = 0;i < values.length;i++){
            System.out.print(values[i] + "\t");
            
            if(( i + 1 ) % 10 == 0){
                System.out.println("\n");
            }
        }
    }
}

Copier après la connexion

Le processus d'utilisation de l'implémentation du tableau est. comme suit :

import java.util.Random;

/**
 * 使用数组实现
 * @Description: 

 * @File: Demo4.java

 * @Package None

 * @Author Hanyonglu

 * @Date 2012-10-18 下午06:27:38

 * @Version V1.0
 */
public class Demo4 {
    public static void main(String[] args) {
        int[] values = new int[20];
        Random random = new Random();
        
        for(int i = 0;i < values.length;i++){
            int number = random.nextInt(100) + 1;
            
            for(int j = 0;j <= i;j++){
                if(number != values[j]){
                    values[i]=number;
                }                              
            }
        }
        
        // 遍历数组并打印数据
        for(int i = 0;i < values.length;i++){
            System.out.print(values[i] + "\t");
            
            if(( i + 1 ) % 10 == 0){
                System.out.println("\n");
            }
        }
    }
}

Copier après la connexion

Les deux processus de mise en œuvre ci-dessus sont relativement inefficaces. Parce que chaque fois que vous l'ajoutez, vous devez déterminer si le nombre existe dans la liste actuelle et 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, comme indiqué dans le code suivant :

import java.util.HashMap;
import java.util.Iterator;
import java.util.Random;
import java.util.Map.Entry;

/**
 * 使用HashMap实现
 * @Description: 

 * @File: Demo.java

 * @Package None

 * @Author Hanyonglu

 * @Date 2012-10-18 下午06:12:50

 * @Version V1.0
 */
public class Demo {
    public static void main(String[] args) {
        int n = 0;
        Object[] values = new Object[20];
        
        Random random = new Random();
        HashMap<Object, Object> hashMap = new HashMap<Object, Object>();
        
        // 生成随机数字并存入HashMap
        for(int i = 0;i < values.length;i++){
            int number = random.nextInt(100) + 1;
            hashMap.put(number, i);
        }
        
        // 从HashMap导入数组
        values = hashMap.keySet().toArray();
        
        // 遍历数组并打印数据
        for(int i = 0;i < values.length;i++){
            System.out.print(values[i] + "\t");
            
            if(( i + 1 ) % 10 == 0){
                System.out.println("\n");
            }
        }
        
//        Iterator iter = hashMap.entrySet().iterator();
//        // 遍历HashMap
//        while (iter.hasNext()) {
//            Entry<Integer, Integer> entry = (Entry)iter.next();
//            int key = entry.getKey();
//            n++;
//            
//            System.out.print(key + "\t");
//            
//            if(n % 10 == 0){
//                System.out.println("\n");
//            }
//        }
    }
}

Copier après la connexion

La relation entre HashSet et HashMap étant trop étroite, HashSet est utilisé en bas HashMap est implémenté, mais il n'y a pas de collection Value, seulement une collection Key, il peut donc également être implémenté en utilisant HashSet, comme indiqué dans le code suivant :

import java.util.HashSet;
import java.util.Random;

/**
 * 使用HashSet实现
 * @Description: 

 * @File: Test.java

 * @Package None

 * @Author Hanyonglu

 * @Date 2012-10-18 下午06:11:41

 * @Version V1.0
 */
public class Test {
    public static void main(String[] args) {
        Random random = new Random();
        Object[] values = new Object[20];
        HashSet<Integer> hashSet = new HashSet<Integer>();
        
        // 生成随机数字并存入HashSet
        for(int i = 0;i < values.length;i++){
            int number = random.nextInt(100) + 1;
            hashSet.add(number);
        }
        
        values = hashSet.toArray();
        
        // 遍历数组并打印数据
        for(int i = 0;i < values.length;i++){
            System.out.print(values[i] + "\t");
            
            if(( i + 1 ) % 10 == 0){
                System.out.println("\n");
            }
        }
    }
}

Copier après la connexion

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 :

import java.util.HashSet;
import java.util.Random;

/**
 * 使用HashSet实现
 * @Description: 

 * @File: Test.java

 * @Package None

 * @Author Hanyonglu

 * @Date 2012-10-18 下午05:11:41

 * @Version V1.0
 */
public class Test {
    public static void main(String[] args) {
        Random random = new Random();
        Object[] values = new Object[20];
        HashSet<Integer> hashSet = new HashSet<Integer>();
        
        // 生成随机数字并存入HashSet
        while(hashSet.size() < values.length){
            hashSet.add(random.nextInt(100) + 1);
        }
        
        values = hashSet.toArray();
        
        // 遍历数组并打印数据
        for(int i = 0;i < values.length;i++){
            System.out.print(values[i] + "\t");
            
            if(( i + 1 ) % 10 == 0){
                System.out.println("\n");
            }
        }
    }
}

Copier après la connexion

Par rapport à ce qui précède, l'efficacité de l'utilisation de HashMap est relativement élevée. En fait, il s'agit de HashSet, puis de array et enfin d'ArrayList. Si nous générons 10 000 éléments de données, nous constaterons que le temps passé à utiliser HashMap est de : 0,05 s, HashSet est de 0,07 s, le tableau est de : 0,20 s et ArrayList est de 0,25 s. Si vous êtes intéressé, vous pouvez fixer une heure pour le vérifier.

Bien sûr, en plus d'utiliser HashMap, il existe d'autres méthodes efficaces. Par exemple, nous pouvons stocker les nombres 1 à 100 dans un tableau, puis générer aléatoirement deux indices dans la boucle for. Si les deux indices ne sont pas égaux, nous pouvons échanger les éléments du tableau. Le processus de mise en œuvre est le suivant :

import java.util.Random;

/**
 * 随机调换位置实现
 * @Description: 

 * @File: Demo4.java

 * @Package None

 * @Author Hanyonglu

 * @Date 2012-10-18 下午06:54:06

 * @Version V1.0
 */
public class Demo4 {
    public static void main(String[] args) {
        int values[] = new int[100];   
        int temp1,temp2,temp3;   
        Random r = new Random();   
        
        for(int i = 0;i < values.length;i++){
            values[i] = i + 1;
        }
        
        //随机交换values.length次   
        for(int i = 0;i < values.length;i++){   
            temp1 = Math.abs(r.nextInt()) % (values.length-1); //随机产生一个位置   
            temp2 = Math.abs(r.nextInt()) % (values.length-1); //随机产生另一个位置   
            
            if(temp1 != temp2){
                temp3 = values[temp1];   
                values[temp1] = values[temp2];   
                values[temp2] = temp3;
            } 
        }   
        
        // 遍历数组并打印数据
        for(int i = 0;i < 20;i++){
            System.out.print(values[i] + "\t");
            
            if(( i + 1 ) % 10 == 0){
                System.out.println("\n");
            }
        }
    }
}

Copier après la connexion

Pour plus d'articles sur Java, veuillez prêter attention au 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!