Wie generiere ich zufällige Ganzzahlen in einem bestimmten Bereich in Java?
Wie generiere ich einen zufälligen int Wert in einem bestimmten Bereich?
Ich habe folgendes versucht, aber die funktionieren nicht:
Versuch 1:
randomNum = minimum + (int)(Math.random() * maximum);
// Bug: `randomNum` can be bigger than `maximum`.
Versuch 2:
Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum = minimum + i;
// Bug: `randomNum` can be smaller than `minimum`.
In Java 1.7 oder höher ist dies standardmäßig der folgende Weg:
import Java.util.concurrent.ThreadLocalRandom;
// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
int randomNum = ThreadLocalRandom.current().nextInt(min, max + 1);
Siehe das entsprechende JavaDoc . Dieser Ansatz hat den Vorteil, dass eine Instanz von Java.util.Random nicht explizit initialisiert werden muss, was bei unsachgemäßer Verwendung zu Verwirrung und Fehlern führen kann.
Umgekehrt gibt es jedoch keine Möglichkeit, den Startwert explizit festzulegen, sodass es schwierig sein kann, die Ergebnisse in Situationen zu reproduzieren, in denen dies nützlich ist, z. In diesen Situationen kann die unten gezeigte Technik vor Java 1.7 verwendet werden.
Vor Java 1.7 ist die Standardmethode wie folgt:
import Java.util.Random;
/**
* Returns a pseudo-random number between min and max, inclusive.
* The difference between min and max can be at most
* <code>Integer.MAX_VALUE - 1</code>.
*
* @param min Minimum value
* @param max Maximum value. Must be greater than min.
* @return Integer between min and max, inclusive.
* @see Java.util.Random#nextInt(int)
*/
public static int randInt(int min, int max) {
// NOTE: This will (intentionally) not run as written so that folks
// copy-pasting have to think about how to initialize their
// Random instance. Initialization of the Random instance is outside
// the main scope of the question, but some decent options are to have
// a field that is initialized once and then re-used as needed or to
// use ThreadLocalRandom (if using at least Java 1.7).
//
// In particular, do NOT do 'Random Rand = new Random()' here or you
// will get not very good / not very random results.
Random Rand;
// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
int randomNum = Rand.nextInt((max - min) + 1) + min;
return randomNum;
}
Siehe das entsprechende JavaDoc . In der Praxis ist die Klasse Java.util.Random oft besser als Java.lang.Math.random () .
Insbesondere ist es nicht erforderlich, das Rad für die Erzeugung von Zufallszahlen ganz neu zu erfinden, wenn sich in der Standardbibliothek eine unkomplizierte API befindet, um die Aufgabe auszuführen.
Beachten Sie, dass dieser Ansatz voreingenommener und weniger effizient ist als ein nextInt-Ansatz, https://stackoverflow.com/a/738651/360211
Ein Standardmuster dafür ist:
Min + (int)(Math.random() * ((Max - Min) + 1))
Die Java Math-Bibliotheksfunktion Math.random () generiert einen doppelten Wert im Bereich [0,1). Beachten Sie, dass dieser Bereich nicht die 1 umfasst.
Um zunächst einen bestimmten Wertebereich zu erhalten, müssen Sie die Größe des Wertebereichs multiplizieren, den Sie abdecken möchten.
Math.random() * ( Max - Min )
Dies gibt einen Wert im Bereich [0,Max-Min) zurück, wobei "Max-Min" nicht enthalten ist.
Wenn Sie beispielsweise [5,10) möchten, müssen Sie fünf ganzzahlige Werte abdecken, damit Sie diese verwenden können
Math.random() * 5
Dies würde einen Wert im Bereich [0,5) zurückgeben, wobei 5 nicht enthalten ist.
Jetzt müssen Sie diesen Bereich auf den Zielbereich verschieben, auf den Sie abzielen. Dazu fügen Sie den Min-Wert hinzu.
Min + (Math.random() * (Max - Min))
Sie erhalten jetzt einen Wert im Bereich [Min,Max). Nach unserem Beispiel bedeutet das [5,10):
5 + (Math.random() * (10 - 5))
Dies beinhaltet jedoch immer noch nicht Max und Sie erhalten einen doppelten Wert. Um den Max-Wert zu erhalten, müssen Sie dem Bereichsparameter (Max - Min) den Wert 1 hinzufügen und dann den Dezimalteil durch Umwandeln in ein int abschneiden. Dies wird erreicht durch:
Min + (int)(Math.random() * ((Max - Min) + 1))
Und da hast du es. Ein zufälliger ganzzahliger Wert im Bereich [Min,Max] oder gemäß dem Beispiel [5,10]:
5 + (int)(Math.random() * ((10 - 5) + 1))
Benutzen:
Random ran = new Random();
int x = ran.nextInt(6) + 5;
Die ganze Zahl x ist jetzt die Zufallszahl, die 5-10 als mögliche Folge hat.
Benutzen:
minimum + rn.nextInt(maxValue - minvalue + 1)
Mit Java-8 wurde die Methode ints(int randomNumberOrigin, int randomNumberBound) in der Random Klasse eingeführt.
Wenn Sie beispielsweise fünf zufällige Ganzzahlen (oder eine einzelne) im Bereich [0, 10] generieren möchten, tun Sie einfach Folgendes:
Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();
Der erste Parameter gibt nur die Größe der generierten IntStream an (die überladene Methode der Methode, die eine unbegrenzte IntStream erzeugt).
Wenn Sie mehrere separate Aufrufe ausführen müssen, können Sie einen unendlichen primitiven Iterator aus dem Stream erstellen:
public final class IntRandomNumberGenerator {
private PrimitiveIterator.OfInt randomIterator;
/**
* Initialize a new random number generator that generates
* random numbers in the range [min, max]
* @param min - the min value (inclusive)
* @param max - the max value (inclusive)
*/
public IntRandomNumberGenerator(int min, int max) {
randomIterator = new Random().ints(min, max + 1).iterator();
}
/**
* Returns a random number in the range (min, max)
* @return a random number in the range (min, max)
*/
public int nextInt() {
return randomIterator.nextInt();
}
}
Sie können dies auch für double- und long-Werte tun.
Ich hoffe es hilft! :)
Sie können Ihr zweites Codebeispiel bearbeiten, um:
Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum = rn.nextInt(range) + minimum;
Schon eine kleine Modifikation Ihrer ersten Lösung würde ausreichen.
Random Rand = new Random();
randomNum = minimum + Rand.nextInt((maximum - minimum) + 1);
Sehen Sie hier mehr zur Implementierung von Random
ThreadLocalRandom-Äquivalent der Klasse Java.util.Random für Multithread-Umgebung. Das Generieren einer Zufallszahl wird lokal in jedem der Threads ausgeführt. Wir haben also eine bessere Leistung, indem wir die Konflikte reduzieren.
int Rand = ThreadLocalRandom.current().nextInt(x,y);
x, y - Intervalle, z.B. (1,10)
Die Math.Random-Klasse in Java ist 0-basiert. Also, wenn du so etwas schreibst:
Random Rand = new Random();
int x = Rand.nextInt(10);
x liegt zwischen 0-9 inklusive.
In Anbetracht des folgenden Arrays von 25-Elementen wäre der Code zum Generieren einer Zufallszahl zwischen 0 (der Basis des Arrays) und array.length:
String[] i = new String[25];
Random Rand = new Random();
int index = 0;
index = Rand.nextInt( i.length );
Da i.length25 zurückgibt, gibt nextInt( i.length ) eine Zahl zwischen dem Bereich von 0-24 zurück. Die andere Option geht mit Math.Random, was auf dieselbe Weise funktioniert.
index = (int) Math.floor(Math.random() * i.length);
Für ein besseres Verständnis schauen Sie im Forum nach Random Intervals (archive.org).
Verzeihen Sie, dass ich anspruchsvoll bin, aber die von der Mehrheit vorgeschlagene Lösung, d. H. min + rng.nextInt(max - min + 1)), scheint gefährlich zu sein, weil:
rng.nextInt(n)kannInteger.MAX_VALUEnicht erreichen.(max - min)kann zu einem Überlauf führen, wennminnegativ ist.
Eine narrensichere Lösung würde korrekte Ergebnisse für jeden min <= max innerhalb von [Integer.MIN_VALUE, Integer.MAX_VALUE] zurückgeben. Betrachten Sie die folgende naive Implementierung:
int nextIntInRange(int min, int max, Random rng) {
if (min > max) {
throw new IllegalArgumentException("Cannot draw random int from invalid range [" + min + ", " + max + "].");
}
int diff = max - min;
if (diff >= 0 && diff != Integer.MAX_VALUE) {
return (min + rng.nextInt(diff + 1));
}
int i;
do {
i = rng.nextInt();
} while (i < min || i > max);
return i;
}
Obwohl ineffizient, beachten Sie, dass die Erfolgswahrscheinlichkeit in der while-Schleife immer mindestens 50% beträgt.
Ich frage mich, ob eine der Methoden zur Erzeugung von Zufallszahlen, die von einer Apache Commons Math Library bereitgestellt werden, der Rechnung entsprechen würde.
Zum Beispiel: RandomDataGenerator.nextInt oder RandomDataGenerator.nextLong
Nehmen wir ein Beispiel.
Angenommen, ich möchte eine Zahl zwischen 5-10 generieren:
int max = 10;
int min = 5;
int diff = max - min;
Random rn = new Random();
int i = rn.nextInt(diff + 1);
i += min;
System.out.print("The Random Number is " + i);
Lasst uns das verstehen ...
Initialisieren Sie max mit dem höchsten Wert und min mit dem niedrigsten Wert.
Nun müssen wir ermitteln, wie viele mögliche Werte erhalten werden können. Für dieses Beispiel wäre das:
5, 6, 7, 8, 9, 10
Dies würde also max - min + 1 zählen.
10 - 5 + 1 = 6
Die Zufallszahl generiert eine Zahl zwischen 0-5 .
0, 1, 2, 3, 4, 5
Das Hinzufügen des min -Wertes zu der Zufallszahl würde Folgendes erzeugen:
5, 6, 7, 8, 9, 10
Somit erhalten wir den gewünschten Bereich.
Rand.nextInt((max+1) - min) + min;
Generieren Sie mit der Methode nextint (n) eine Zufallszahl für die Differenz von min und max und fügen Sie dem Ergebnis dann eine min-Zahl hinzu:
Random rn = new Random();
int result = rn.nextInt(max - min + 1) + min;
System.out.println(result);
Ab Java 7 sollten Sie
Randomnicht mehr verwenden. Für die meisten Zwecke ist der Zufallszahlengenerator der Wahl ist jetztThreadLocalRandom.
Für Fork-Join-Pools und Parallel Streams verwenden SieSplittableRandom.
Joshua Bloch. Effektives Java. Dritte Edition.
Beginnend mit Java 8
Für Fork-Join-Pools und parallele Streams verwenden Sie SplittableRandom, das normalerweise schneller ist und im Vergleich zu Random eine bessere statistische Unabhängigkeit und Einheitlichkeit aufweist.
So generieren Sie eine zufällige int im Bereich [0, 1_000]:
int n = new SplittableRandom().nextInt(0, 1_001);
So generieren Sie ein int[100]-Array mit Werten im Bereich [0, 1_000]:
int[] a = new SplittableRandom().ints(100, 0, 1_001).parallel().toArray();
So geben Sie einen Stream mit zufälligen Werten zurück:
IntStream stream = new SplittableRandom().ints(100, 0, 1_001);
Im Falle des Würfelns eines Würfels wäre dies eine Zufallszahl zwischen 1 und 6 (nicht 0 bis 6), also:
face = 1 + randomNumbers.nextInt(6);
Hier ist eine hilfreiche Klasse zum Generieren von zufälligen ints in einem Bereich mit einer beliebigen Kombination von inklusiven/exklusiven Grenzen:
import Java.util.Random;
public class RandomRange extends Random {
public int nextIncInc(int min, int max) {
return nextInt(max - min + 1) + min;
}
public int nextExcInc(int min, int max) {
return nextInt(max - min) + 1 + min;
}
public int nextExcExc(int min, int max) {
return nextInt(max - min - 1) + 1 + min;
}
public int nextIncExc(int min, int max) {
return nextInt(max - min) + min;
}
}
int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();
Oder werfen Sie einen Blick auf RandomUtils aus Apache Commons .
Verwenden Sie den folgenden Code, um eine Zufallszahl "zwischen zwei Zahlen" zu generieren:
Random r = new Random();
int lowerBound = 1;
int upperBound = 11;
int result = r.nextInt(upperBound-lowerBound) + lowerBound;
Dadurch erhalten Sie eine Zufallszahl zwischen 1 (einschließlich) und 11 (exklusiv). Initialisieren Sie den Wert von upperBound, indem Sie 1 hinzufügen. Wenn Sie beispielsweise eine Zufallszahl zwischen 1 und 10 generieren möchten, dann initialisieren Sie die obere Zahl mit 11 anstelle von 10.
Diese Methoden sind möglicherweise bequem zu verwenden:
Diese Methode gibt eine Zufallszahlzwischendem angegebenen Mindest- und Höchstwert zurück:
public static int getRandomNumberBetween(int min, int max) {
Random foo = new Random();
int randomNumber = foo.nextInt(max - min) + min;
if (randomNumber == min) {
// Since the random number is between the min and max values, simply add 1
return min + 1;
} else {
return randomNumber;
}
}
und diese Methode gibt eine Zufallszahlausdes angegebenen Min- und Max-Werts zurück (die generierte Zahl könnte auch die Min- oder Max-Zahl sein):
public static int getRandomNumberFrom(int min, int max) {
Random foo = new Random();
int randomNumber = foo.nextInt((max + 1) - min) + min;
return randomNumber;
}
Verwenden Sie einfach die Random -Klasse:
Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 1);
Ich habe dieses Beispiel gefunden Zufallszahlen generieren :
In diesem Beispiel werden zufällige Ganzzahlen in einem bestimmten Bereich generiert.
import Java.util.Random;
/** Generate random integers in a certain range. */
public final class RandomRange {
public static final void main(String... aArgs){
log("Generating random integers in the range 1..10.");
int START = 1;
int END = 10;
Random random = new Random();
for (int idx = 1; idx <= 10; ++idx){
showRandomInteger(START, END, random);
}
log("Done.");
}
private static void showRandomInteger(int aStart, int aEnd, Random aRandom){
if ( aStart > aEnd ) {
throw new IllegalArgumentException("Start cannot exceed End.");
}
//get the range, casting to long to avoid overflow problems
long range = (long)aEnd - (long)aStart + 1;
// compute a fraction of the range, 0 <= frac < range
long fraction = (long)(range * aRandom.nextDouble());
int randomNumber = (int)(fraction + aStart);
log("Generated : " + randomNumber);
}
private static void log(String aMessage){
System.out.println(aMessage);
}
}
Ein Beispiellauf dieser Klasse:
Generating random integers in the range 1..10.
Generated : 9
Generated : 3
Generated : 3
Generated : 9
Generated : 4
Generated : 1
Generated : 3
Generated : 9
Generated : 10
Generated : 10
Done.
Das können Sie in Java 8 prägnant erreichen:
Random random = new Random();
int max = 10;
int min = 5;
int totalNumber = 10;
IntStream stream = random.ints(totalNumber, min, max);
stream.forEach(System.out::println);
Wenn Sie viele Zufallszahlen benötigen, empfehle ich nicht die Random-Klasse in der API. Es hat nur eine zu kleine Periode. Versuchen Sie stattdessen den Mersenne-Twister . Es gibt eine Java-Implementierung .
public static Random RANDOM = new Random(System.nanoTime());
public static final float random(final float pMin, final float pMax) {
return pMin + RANDOM.nextFloat() * (pMax - pMin);
}
Eine andere Option ist nur die Verwendung von Apache Commons :
import org.Apache.commons.math.random.RandomData;
import org.Apache.commons.math.random.RandomDataImpl;
public void method() {
RandomData randomData = new RandomDataImpl();
int number = randomData.nextInt(5, 10);
// ...
}
Hier ein einfaches Beispiel, das zeigt, wie eine Zufallszahl aus dem geschlossenen [min, max]-Bereich generiert wird, während min <= max is true
Sie können es als Feld in der Bohrungsklasse wiederverwenden, wobei alle Random.class-Methoden an einem Ort vorhanden sind
Ergebnisbeispiel:
RandomUtils random = new RandomUtils();
random.nextInt(0, 0); // returns 0
random.nextInt(10, 10); // returns 10
random.nextInt(-10, 10); // returns numbers from -10 to 10 (-10, -9....9, 10)
random.nextInt(10, -10); // throws assert
Quellen:
import junit.framework.Assert;
import Java.util.Random;
public class RandomUtils extends Random {
/**
* @param min generated value. Can't be > then max
* @param max generated value
* @return values in closed range [min, max].
*/
public int nextInt(int min, int max) {
Assert.assertFalse("min can't be > then max; values:[" + min + ", " + max + "]", min > max);
if (min == max) {
return max;
}
return nextInt(max - min + 1) + min;
}
}
private static Random random = new Random();
public static int getRandomInt(int min, int max){
return random.nextInt(max - min + 1) + min;
}
OR
public static int getRandomInt(Random random, int min, int max)
{
return random.nextInt(max - min + 1) + min;
}
Wenn Sie die Antwort mit den meisten Stimmen oben ausprobieren möchten, können Sie einfach diesen Code verwenden:
public class Randomizer
{
public static int generate(int min,int max)
{
return min + (int)(Math.random() * ((max - min) + 1));
}
public static void main(String[] args)
{
System.out.println(Randomizer.generate(0,10));
}
}
Es ist einfach sauber und einfach.
Es ist besser, SecureRandom als Random zu verwenden.
public static int generateRandomInteger(int min, int max) {
SecureRandom Rand = new SecureRandom();
Rand.setSeed(new Date().getTime());
int randomNum = Rand.nextInt((max - min) + 1) + min;
return randomNum;
}
Rand.nextInt((max+1) - min) + min;
Das funktioniert gut.
Ich benutze das:
/**
* @param min - The minimum.
* @param max - The maximum.
* @return A random double between these numbers (inclusive the minimum and maximum).
*/
public static double getRandom(double min, double max) {
return (Math.random() * (max+1-min)) + min;
}
Sie können es in eine Ganzzahl umwandeln, wenn Sie möchten.
import Java.util.Random;
public class RandomUtil {
// Declare as class variable so that it is not re-seeded every call
private static Random random = new Random();
/**
* Returns a psuedo-random number between min and max (both inclusive)
* @param min Minimim value
* @param max Maximim value. Must be greater than min.
* @return Integer between min and max (both inclusive)
* @see Java.util.Random#nextInt(int)
*/
public static int nextInt(int min, int max) {
// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
return random.nextInt((max - min) + 1) + min;
}
}
Sie können so etwas tun:
import Java.awt.*;
import Java.io.*;
import Java.util.*;
import Java.math.*;
public class Test {
public static void main(String[] args) {
int first, second;
Scanner myScanner = new Scanner(System.in);
System.out.println("Enter first integer: ");
int numOne;
numOne = myScanner.nextInt();
System.out.println("You have keyed in " + numOne);
System.out.println("Enter second integer: ");
int numTwo;
numTwo = myScanner.nextInt();
System.out.println("You have keyed in " + numTwo);
Random generator = new Random();
int num = (int)(Math.random()*numTwo);
System.out.println("Random number: " + ((num>numOne)?num:numOne+num));
}
}
Sie können dieses Code-Snippet verwenden, um Ihr Problem zu beheben:
Random r = new Random();
int myRandomNumber = 0;
myRandomNumber = r.nextInt(maxValue-minValue+1)+minValue;
Verwenden Sie myRandomNumber (damit erhalten Sie eine Nummer innerhalb eines Bereichs).
Ein anderer Ansatz mit Java 8 IntStream und Collections.shuffle
import Java.util.stream.IntStream;
import Java.util.ArrayList;
import Java.util.Collections;
public class Main {
public static void main(String[] args) {
IntStream range = IntStream.rangeClosed(5,10);
ArrayList<Integer> ls = new ArrayList<Integer>();
//populate the ArrayList
range.forEach(i -> ls.add(new Integer(i)) );
//perform a random shuffle using the Collections Fisher-Yates shuffle
Collections.shuffle(ls);
System.out.println(ls);
}
}
Das Äquivalent in Scala
import scala.util.Random
object RandomRange extends App{
val x = Random.shuffle(5 to 10)
println(x)
}
Ich werde einfach sagen, was mit den Lösungen der Frage falsch ist und warum die Fehler.
Lösung 1:
randomNum = minimum + (int)(Math.random()*maximum);
Problem: randomNum erhält Werte, die größer als das Maximum sind.
Erläuterung: Angenommen, unser Minimum ist 5 und Ihr Maximum ist 10. Jeder Wert von Math.random() größer als 0,6 führt dazu, dass der Ausdruck mit 6 oder höher bewertet wird. Wenn Sie 5 hinzufügen, wird er größer als 10 (Ihr Maximum). Das Problem ist, dass Sie die Zufallszahl mit dem Maximum multiplizieren (was eine Zahl erzeugt, die fast so groß ist wie das Maximum) und dann das Minimum addieren. Wenn das Minimum nicht 1 ist, ist es nicht korrekt. Sie müssen zu wechseln, wie in anderen Antworten erwähnt
randomNum = minimum + (int)(Math.random()*(maximum-minimum+1))
Das +1 ist, weil Math.random() niemals 1,0 zurückgibt.
Lösung 2:
Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum = minimum + i;
Ihr Problem hier ist, dass '%' eine negative Zahl zurückgeben kann, wenn der erste Ausdruck kleiner als 0 ist. Da rn.nextInt() negative Werte mit einer Wahrscheinlichkeit von ~ 50% zurückgibt, erhalten Sie auch nicht das erwartete Ergebnis.
Dies war jedoch fast perfekt. Sie mussten nur etwas weiter in den Javadoc hineinschauen, nextInt (int n) . Mit dieser Methode zur Verfügung
Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt(n);
randomNum = minimum + i;
Würde auch das gewünschte Ergebnis zurückgeben.
Random random = new Random();
int max = 10;
int min = 3;
int randomNum = random.nextInt(max) % (max - min + 1) + min;
Du könntest benutzen
RandomStringUtils.randomNumeric(int count)
methode auch, die von Apache Commons ist.
import Java.util.Random;
public class RandomSSNTest {
public static void main(String args[]) {
generateDummySSNNumber();
}
//831-33-6049
public static void generateDummySSNNumber() {
Random random = new Random();
int id1 = random.nextInt(1000);//3
int id2 = random.nextInt(100);//2
int id3 = random.nextInt(10000);//4
System.out.print((id1+"-"+id2+"-"+id3));
}
}
Sie können auch verwenden
import Java.util.concurrent.ThreadLocalRandom;
Random random = ThreadLocalRandom.current();
In einer Umgebung mit mehreren Threads ist diese Klasse jedoch nicht gut.
Die folgende Änderung in Versuch 1 sollte die Arbeit erledigen -
randomNum = minimum + (int)(Math.random() * (maximum - minimum) );
Überprüfen Sie dies für den Arbeitscode.
Ich denke, die erzeugten Zufallszahlen linear in den gewünschten Bereich zu normalisieren, indem Sie Folgendes verwenden. Sei x eine Zufallszahl, sei a und b der minimale und maximale Bereich der gewünschten normalisierten Zahl.
Nachfolgend finden Sie nur ein sehr einfaches Code-Snipplet, um den durch das lineare Mapping erzeugten Bereich zu testen.
public static void main(String[] args) {
int a = 100;
int b = 1000;
int lowest = b;
int highest = a;
int count = 100000;
Random random = new Random();
for (int i = 0; i < count; i++) {
int nextNumber = (int) ((Math.abs(random.nextDouble()) * (b - a))) + a;
if (nextNumber < a || nextNumber > b) {
System.err.println("number not in range :" + nextNumber);
}
else {
System.out.println(nextNumber);
}
if (nextNumber < lowest) {
lowest = nextNumber;
}
if (nextNumber > highest) {
highest = nextNumber;
}
}
System.out.println("Produced " + count + " numbers from " + lowest
+ " to " + highest);
}
Ich generiere einfach eine Zufallszahl mit Math.random () und multipliziere sie mit einer großen Zahl, sagen wir 10000. Also bekomme ich eine Zahl zwischen 0 und 10.000 und nenne diese Zahl i. Wenn ich jetzt Zahlen zwischen (x, y) brauche, dann mache folgendes:
i = x + (i % (y - x));
Also sind alle i Zahlen zwischen x und y.
Um die Abweichung wie in den Kommentaren erwähnt zu entfernen, anstatt sie mit 10000 (oder der großen Zahl) zu multiplizieren, multiplizieren Sie sie mit (y-x).
Ich denke, dass dieser Code dafür funktionieren wird. Bitte versuchen Sie das:
import Java.util.Random;
public final class RandomNumber {
public static final void main(String... aArgs) {
log("Generating 10 random integers in range 1..10.");
int START = 1;
int END = 10;
Random randomGenerator = new Random();
for (int idx=1; idx<=10; ++idx) {
// int randomInt=randomGenerator.nextInt(100);
// log("Generated : " + randomInt);
showRandomInteger(START,END,randomGenerator);
}
log("Done");
}
private static void log(String aMessage) {
System.out.println(aMessage);
}
private static void showRandomInteger(int aStart, int aEnd, Random aRandom) {
if (aStart > aEnd) {
throw new IllegalArgumentException("Start cannot exceed End.");
}
long range = (long)aEnd - (long)aStart + 1;
long fraction = (long) (range * aRandom.nextDouble());
int randomNumber = (int) (fraction + aStart);
log("Generated" + randomNumber);
}
}
Wenn Sie bereits Commons Lang API 2.x oder die neueste Version verwenden, gibt es eine Klasse für die Generierung von Zufallszahlen RandomUtils.
public static int nextInt(int n)
Gibt einen pseudozufälligen, gleichverteilten int-Wert zwischen 0 (einschließlich) und dem angegebenen Wert (exklusiv) aus der Sequenz Math.random () zurück.
Parameter: n - der angegebene exklusive Maximalwert
int random = RandomUtils.nextInt(1000000);
Hinweis: In RandomUtils gibt es viele Methoden zur Erzeugung von Zufallszahlen
Der folgende Code generiert eine Zufallszahl zwischen 100.000 und 900.000. Dieser Code generiert sechsstellige Werte. Ich verwende diesen Code, um eine sechsstellige OTP zu generieren.
Verwenden Sie import Java.util.Random, um diese Zufallsmethode zu verwenden.
import Java.util.Random;
// Six digits random number generation for OTP
Random rnd = new Random();
long longregisterOTP = 100000 + rnd.nextInt(900000);
System.out.println(longregisterOTP);
Sie können entweder die Random-Klasse verwenden, um eine Zufallszahl zu generieren, und dann die .nextInt (maxNumber) verwenden, um eine Zufallszahl zu generieren. Die maxNumber ist die Nummer, die Sie beim Generieren einer Zufallszahl maximal benötigen. Denken Sie jedoch daran, dass die Random-Klasse Ihnen die Zahlen 0 bis maxNumber-1 gibt.
Random r = new Random();
int i = r.nextInt();
Eine andere Möglichkeit besteht darin, die Math.Random () - Klasse zu verwenden, für die Sie viele Klassen in Schulen verwenden müssen, da diese effizienter ist und Sie kein neues Zufallsobjekt deklarieren müssen. Um eine Zufallszahl mit Math.Random () zu erhalten, geben Sie Folgendes ein:
Math.random() * (max - min) + min;
Dadurch wird Zufallszahlenliste mit Bereich (Min - Max) mit kein Duplikat generiert.
generateRandomListNoDuplicate(1000, 8000, 500);
Fügen Sie diese Methode hinzu.
private void generateRandomListNoDuplicate(int min, int max, int totalNoRequired) {
Random rng = new Random();
Set<Integer> generatedList = new LinkedHashSet<>();
while (generatedList.size() < totalNoRequired) {
Integer radnomInt = rng.nextInt(max - min + 1) + min;
generatedList.add(radnomInt);
}
}
Hoffe, das wird dir helfen.
Ich habe eine Methode erstellt, um eine eindeutige ganze Zahl in einem bestimmten Bereich zu erhalten.
/*
* minNum is the minimum possible random number
* maxNum is the maximum possible random number
* numbersNeeded is the quantity of random number required
* the give method provides you with unique random number between min & max range
*/
public static Set<Integer> getUniqueRandomNumbers( int minNum , int maxNum ,int numbersNeeded ){
if(minNum >= maxNum)
throw new IllegalArgumentException("maxNum must be greater than minNum");
if(! (numbersNeeded > (maxNum - minNum + 1) ))
throw new IllegalArgumentException("numberNeeded must be greater then difference b/w (max- min +1)");
Random rng = new Random(); // Ideally just create one instance globally
// Note: use LinkedHashSet to maintain insertion order
Set<Integer> generated = new LinkedHashSet<Integer>();
while (generated.size() < numbersNeeded)
{
Integer next = rng.nextInt((maxNum - minNum) + 1) + minNum;
// As we're adding to a set, this will automatically do a containment check
generated.add(next);
}
return generated;
}
Angenommen, Sie möchten einen Bereich zwischen 0-9, 0 ist Minimum und 9 ist Maximum. Die folgende Funktion druckt alles zwischen 0 und 9. Sie ist für alle Bereiche gleich.
public static void main(String[] args) {
int b = randomNumberRange(0, 9);
int d = randomNumberRange (100, 200);
System.out.println("value of b is " + b);
System.out.println("value of d is " + d);
}
public static int randomNumberRange(int min, int max) {
int n = (max + 1 - min) + min;
return (int) (Math.random() * n);
}
Einer meiner Freunde hatte mir heute an der Universität die gleiche Frage gestellt (seine Anforderung lautete, eine Zufallszahl zwischen 1 und -1 zu erzeugen). Also habe ich das geschrieben und es funktioniert soweit gut mit meinen Tests. Es gibt im Idealfall viele Möglichkeiten, Zufallszahlen für einen Bereich zu generieren. Versuche dies:
Funktion:
private static float getRandomNumberBetween(float numberOne, float numberTwo) throws Exception{
if (numberOne == numberTwo){
throw new Exception("Both the numbers can not be equal");
}
float Rand = (float) Math.random();
float highRange = Math.max(numberOne, numberTwo);
float lowRange = Math.min(numberOne, numberTwo);
float lowRand = (float) Math.floor(Rand-1);
float highRand = (float) Math.ceil(Rand+1);
float genRand = (highRange-lowRange)*((Rand-lowRand)/(highRand-lowRand))+lowRange;
return genRand;
}
Führen Sie so aus:
System.out.println( getRandomNumberBetween(1,-1));
Das folgende ist ein weiteres Beispiel, das Random und forEach verwendet
int firstNum = 20;//Inclusive
int lastNum = 50;//Exclusive
int streamSize = 10;
Random num = new Random().ints(10, 20, 50).forEach(System.out::println);
Es gibt eine Bibliothek unter https://sourceforge.net/projects/stochunit/ zur Handhabung der Auswahl von Bereichen.
StochIntegerSelector randomIntegerSelector = new StochIntegerSelector();
randomIntegerSelector.setMin(-1);
randomIntegerSelector.setMax(1);
Integer selectInteger = randomIntegerSelector.selectInteger();
Es hat Randeinschluss/Ausschluss.
Eine einfache Möglichkeit, n Zufallszahlen zwischen a und b zu erzeugen, z. B. a = 90, b = 100, n = 20
Random r = new Random();
for(int i =0; i<20; i++){
System.out.println(r.ints(90, 100).iterator().nextInt());
}
r.ints() gibt eine IntStream zurück und hat mehrere nützliche Methoden. Schauen Sie sich ihre API an.
Versuchen Sie es mit org.Apache.commons.lang.RandomStringUtils class. Ja, manchmal gibt es eine wiederholte Zahl nebeneinander, aber es wird ein Wert zwischen 5 und 15 angegeben
while (true)
{
int abc = Integer.valueOf(RandomStringUtils.randomNumeric(1));
int cd = Integer.valueOf(RandomStringUtils.randomNumeric(2));
if ((cd-abc) >= 5 && (cd-abc) <= 15)
{
System.out.println(cd-abc);
break;
}
}
Zufallszahl aus dem Bereich [min..max] inklusive:
int randomFromMinToMaxInclusive = ThreadLocalRandom.current()
.nextInt(min, max + 1);
Verwenden Sie Java.util für Random für die allgemeine Verwendung.
Sie können Ihren minimalen und maximalen Bereich definieren, um diese Ergebnisse zu erhalten.
Random Rand=new Random();
Rand.nextInt((max+1) - min) + min;
Die meisten der oben genannten Vorschläge berücksichtigen nicht 'Überlauf'. Zum Beispiel: min = Integer.MIN_VALUE, max = 100. Einer der korrekten Ansätze, die ich bisher habe, ist:
final long mod = max- min + 1L;
final int next = (int) (Math.abs(Rand.nextLong() % mod) + min);
Dies ist der einfache Weg, dies zu tun.
import Java.util.Random;
class Example{
public static void main(String args[]){
/*-To test-
for(int i = 1 ;i<20 ; i++){
System.out.print(randomnumber()+",");
}
*/
int randomnumber = randomnumber();
}
public static int randomnumber(){
Random Rand = new Random();
int randomNum = Rand.nextInt(6) + 5;
return randomNum;
}
}
Dort ist 5 der Startpunkt von Zufallszahlen. 6 ist der Bereich einschließlich der Nummer 5.
hier ist eine Funktion, die genau eine ganzzahlige Zufallszahl in einem durch definierten Bereich zurückgibtlowerBoundIncludedndupperBoundIncluded, wie von angefordert = user42155
SplittableRandom splittableRandom = new SplittableRandom();
BiFunction<Integer,Integer,Integer> randomInt = (lowerBoundIncluded, upperBoundIncluded)
-> splittableRandom.nextInt( lowerBoundIncluded, upperBoundIncluded + 1 );
randomInt.apply( …, … ); // gets the random number
… oder kürzer für die einmalige Erzeugung einer Zufallszahl
new SplittableRandom().nextInt( lowerBoundIncluded, upperBoundIncluded + 1 );
public static void main(String[] args) {
Random ran = new Random();
int min, max;
Scanner sc = new Scanner(System.in);
System.out.println("Enter min range:");
min = sc.nextInt();
System.out.println("Enter max range:");
max = sc.nextInt();
int num = ran.nextInt(min);
int num1 = ran.nextInt(max);
System.out.println("Random Number between given range is " + num1);
}
Verwenden Sie math.random() und legen Sie die Anforderungen in der if-Anweisung fest. Der einfachste, einfachste und schnellste Ansatz
Java 8 Streams verwenden,
- Übergeben Sie die anfängliche Kapazität - wie viele Zahlen
- Übergeben Sie randomBound - von x an randomBound
- Übergeben Sie true/false für sortiert oder nicht
- Übergeben Sie ein neues Objekt Random ()
public static List<Integer> generateNumbers(int initialCapacity, int randomBound, Boolean sorted, Random random) {
List<Integer> numbers = random.ints(initialCapacity, 1, randomBound).boxed().collect(Collectors.toList());
if (sorted)
numbers.sort(null);
return numbers;
}
In diesem Beispiel werden Zahlen aus 1-Randombound generiert.
Nachfolgend finden Sie eine Beispielklasse, in der gezeigt wird, wie Zufallszahlen innerhalb eines bestimmten Bereichs generiert werden. Weisen Sie der Variablen 'max' einen beliebigen Wert als Maximalwert zu, und weisen Sie der Variablen 'min' einen beliebigen Wert als Minimalwert zu.
public class RandomTestClass {
public static void main(String[] args) {
Random r = new Random();
int max = 10;
int min = 5;
int x;
x = r.nextInt(max) + min;
System.out.println(x);
}
}
Folgender Code könnte verwendet werden:
ThreadLocalRandom.current().nextInt(rangeStart, rangeEndExclusive)