Zusammenfassung der Java-Methoden zum Generieren sich nicht wiederholender Zufallszahlen

In diesem Artikel erfahren Sie, wie Sie die Funktion zufälliger, sich nicht wiederholender Zahlen in JAVA implementieren. (Empfohlene verwandte Videokurse: Java-Video-Tutorial)

Um die Bedeutung dieser Frage besser zu verstehen, werfen wir zunächst einen Blick auf den spezifischen Inhalt: Generieren Sie ein zufälliges Array von 1- 100, aber das Array Die Zahlen in können nicht wiederholt werden, dh die Positionen sind zufällig, aber die Array-Elemente können nicht wiederholt werden.

Hier ist die Länge des Arrays für uns nicht angegeben, wir können eine beliebige Länge zwischen 1 und 100 festlegen.

Als nächstes werfen wir einen Blick auf verschiedene Implementierungsmethoden und vergleichen sie.

Normalerweise verwenden wir ArrayList oder Array, um es zu implementieren. Schauen wir uns zunächst den ArrayList-Implementierungsprozess an, wie im folgenden Code gezeigt:

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");
            }
        }
    }
}

Der Prozess der Array-Implementierung ist wie folgt:

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");
            }
        }
    }
}

Die beiden oben genannten Implementierungsprozesse sind relativ ineffizient. Denn jedes Mal, wenn Sie es hinzufügen, müssen Sie durchlaufen, ob die Zahl in der aktuellen Liste vorhanden ist und die zeitliche Komplexität O (N ^ 2) beträgt. Wir können es uns so vorstellen: Da es keine Duplizierung gibt, können wir über die Funktionen von HashSet und HashMap nachdenken.

HashSet implementiert die Set-Schnittstelle. Die mathematische Definition von Set ist eine Sammlung ohne Duplizierung und Reihenfolge. HashMap implementiert Map und lässt keine doppelten Schlüssel zu. Auf diese Weise können wir HashMap oder HashSet verwenden, um dies zu erreichen.

Wenn Sie HashMap zum Implementieren verwenden, müssen Sie nur seinen Schlüssel in ein Array konvertieren, wie im folgenden Code gezeigt:

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");
//            }
//        }
    }
}

Da die Beziehung zwischen HashSet und HashMap zu eng ist, ist HashSet Unten wird HashMap implementiert, aber es gibt keine Wertesammlung, sondern nur eine Schlüsselsammlung, daher kann es auch mit HashSet implementiert werden, wie im folgenden Code gezeigt:

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");
            }
        }
    }
}

Diese Implementierung ist etwas effizienter . Wenn wir die Länge des Arrays begrenzen, müssen wir nur die for-Schleife ändern und sie in eine whlie-Schleife umwandeln. Wie unten gezeigt:

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");
            }
        }
    }
}

Im Vergleich zu den oben genannten ist die Effizienz der Verwendung von HashMap relativ hoch. Tatsächlich handelt es sich um HashSet, dann um Array und schließlich um ArrayList. Wenn wir 10.000 Daten generieren, werden wir feststellen, dass die für die Verwendung von HashMap aufgewendete Zeit 0,05 s, HashSet 0,07 s, Array 0,20 s und ArrayList 0,25 s beträgt. Wenn Sie interessiert sind, können Sie einen Termin zur Besichtigung vereinbaren.

Natürlich gibt es neben der Verwendung von HashMap noch andere effiziente Methoden. Beispielsweise können wir die Zahlen 1-100 in einem Array speichern und dann zufällig zwei Indizes in der for-Schleife generieren. Wenn die beiden Indizes nicht gleich sind, können wir die Elemente im Array wie folgt austauschen:

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");
            }
        }
    }
}

Weitere Artikel zum Thema Java finden Sie im Java Basic Tutorial.

Das obige ist der detaillierte Inhalt vonZusammenfassung der Java-Methoden zum Generieren sich nicht wiederholender Zufallszahlen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!