Im Allgemeinen können Freunde mit etwas Entwicklungserfahrung eine solche Funktion realisieren, es ist jedoch nur eine Frage der Effizienz. Wenn wir normalerweise auf ein solches Problem stoßen, denken wir immer in flacher Reihenfolge darüber nach. Generieren Sie zunächst ein Array und fügen Sie dann in einer Schleife Zufallszahlen hinzu. Überprüfen Sie beim Hinzufügen von Zahlen zunächst, ob sie im Array vorhanden sind . Wenn diese Nummer nicht vorhanden ist, wird sie direkt zum Array hinzugefügt. Wenn sie vorhanden ist, wird sie nicht hinzugefügt. Im Allgemeinen denken wir auf diese Weise über Probleme nach, und durch diese Denkweise können Funktionen erreicht werden. Wie ich gerade sagte, ist es nur eine Frage der Effizienz.
Um die Bedeutung dieser Frage besser zu verstehen, schauen wir uns zunächst den spezifischen Inhalt an: Erzeugen Sie ein zufälliges Array von 1 bis 100, aber die Zahlen im Array können nicht wiederholt werden, dh die Position ist zufällig, die Array-Elemente jedoch kann nicht wiederholt werden. Hier ist uns die Länge des Arrays nicht vorgegeben, wir können eine beliebige Länge zwischen 1 und 100 festlegen.
Schauen wir uns als nächstes an, wie wir es besser implementieren können. Normalerweise verwenden wir ArrayList, um es zu implementieren, wie im folgenden Code gezeigt:
Kopieren Sie den Codecode wie folgt:
Paket cn.sunzn.randomnumber;
import java.util.ArrayList;
java.util.Random importieren;
Demo der öffentlichen Klasse {
public static void main(String[] args) {
Object[]-Werte = neues Objekt[20];
Zufällig random = new Random();
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < Werte.Länge; i++) {
int Zahl = random.nextInt(100) + 1;
if (!list.contains(number)) {
list.add(Nummer);
}
}
Werte = list.toArray();
/************ Das Array durchlaufen und die Daten drucken************/
for (int i = 0; i < Werte.Länge; i++) {
System.out.print(values[i] + „/t“);
if ((i + 1) % 10 == 0) {
System.out.println("/n");
}
}
}
}
Der obige Implementierungsprozess ist relativ ineffizient. Da jedes Mal, wenn Sie es hinzufügen, überprüft werden muss, ob die Zahl in der aktuellen Liste vorhanden ist, beträgt die zeitliche Komplexität O (N ^ 2). 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 zur Implementierung verwenden, müssen Sie nur seinen Schlüssel in ein Array konvertieren. Der Code lautet wie folgt:
Kopieren Sie den Codecode wie folgt:
Paket cn.sunzn.randomnumber;
import java.util.HashMap;
import java.util.Random;
Demo der öffentlichen Klasse {
public static void main(String[] args) {
Object[]-Werte = neues Objekt[20];
Zufällig random = new Random();
HashMap<Object, Object> hashMap = new HashMap<Object, Object>();
/******* Zufallszahlen generieren und in HashMap speichern *******/
for (int i = 0; i < Werte.Länge; i++) {
int Zahl = random.nextInt(100) + 1;
hashMap.put(number, i);
}
/*************** Array aus HashMap importieren***************/
Werte = hashMap.keySet().toArray();
/*********** Durchquere das Array und drucke die Daten*************/
for (int i = 0; i < Werte.Länge; i++) {
System.out.print(values[i] + „/t“);
if ((i + 1) % 10 == 0) {
System.out.println("/n");
}
}
}
}
Da die Beziehung zwischen HashSet und HashMap zu eng ist, wird HashSet mit HashMap auf der untersten Ebene implementiert. Es gibt jedoch keine Sammlung von Werten, sondern nur eine Sammlung von Schlüsseln, sodass es auch mit HashSet implementiert werden kann :
Kopieren Sie den Codecode wie folgt:
Paket cn.sunzn.randomnumber;
import java.util.HashSet;
import java.util.Random;
Demo der öffentlichen Klasse {
public static void main(String[] args) {
Zufällig random = new Random();
Object[]-Werte = neues Objekt[20];
HashSet<Integer> hashSet = new HashSet<Integer>();
/******* Zufallszahlen generieren und in HashSet speichern *******/
for (int i = 0; i < Werte.Länge; i++) {
int Zahl = random.nextInt(100) + 1;
hashSet.add(Nummer);
}
Werte = hashSet.toArray();
/************* Das Array durchlaufen und die Daten drucken**********/
for (int i = 0; i < Werte.Länge; 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:
Kopieren Sie den Codecode wie folgt:
Paket cn.sunzn.randomnumber;
import java.util.HashSet;
import java.util.Random;
Demo der öffentlichen Klasse {
public static void main(String[] args) {
Zufällig random = new Random();
Object[]-Werte = neues Objekt[20];
HashSet<Integer> hashSet = new HashSet<Integer>();
/****** Zufallszahlen generieren und in HashSet speichern ******/
while (hashSet.size() <values.length) {
hashSet.add(random.nextInt(100) + 1);
}
Werte = hashSet.toArray();
/************ Das Array durchlaufen und die Daten drucken************/
for (int i = 0; i < Werte.Länge; i++) {
System.out.print(values[i] + „/t“);
if ((i + 1) % 10 == 0) {
System.out.println("/n");
}
}
}
}