Generieren Sie ein zufälliges Double in einem Bereich

Ich habe zwei Doppel wie das folgende

double min = 100;
double max = 101;

und mit einem Zufallsgenerator muss ich einen doppelten Wert zwischen dem Bereich von min und max erstellen.

Random r = new Random();
r.nextDouble();

Hier gibt es jedoch nichts, wo wir den Bereich angeben können.

So generieren Sie einen zufälligen Wert zwischen rangeMinund rangeMax:

Random r = new Random();
double randomValue = rangeMin + (rangeMax - rangeMin) * r.nextDouble();

Diese Frage wurde vor der Veröffentlichung von Java 7 gestellt, aber jetzt gibt es eine andere Möglichkeit, die Java 7-API (und höher) zu verwenden:

double random = ThreadLocalRandom.current().nextDouble(min, max);

nextDoublegibt einen pseudozufälligen Doppelwert zwischen dem Minimum (einschließlich) und dem Maximum (exklusiv) zurück. Die Grenzen sind nicht unbedingt intund können es auch sein double.

Benutze das:

double start = 400;
double end = 402;
double random = new Random().nextDouble();
double result = start + (random * (end - start));
System.out.println(result);

BEARBEITEN:

new Random().nextDouble(): generiert zufällig eine Zahl zwischen 0 und 1.

start: Startnummer, um die Nummer "nach rechts" zu verschieben

end - start: Intervall. Zufällig gibt Ihnen 0% bis 100% dieser Zahl, weil Zufall eine Zahl von 0 bis 1 ergibt.

EDIT 2: Tks @daniel und @aaa bbb. Meine erste Antwort war falsch.

import java.util.Random;

public class MyClass {
     public static void main(String args[]) {
          Double min = 0.0;  // Set To Your Desired Min Value
          Double max = 10.0; // Set To Your Desired Max Value
          double x = (Math.random() * ((max - min) + 1)) + min;   // This Will Create A Random Number Inbetween Your Min And Max.
          double xrounded = Math.round(x * 100.0) / 100.0;   // Creates Answer To The Nearest 100 th, You Can Modify This To Change How It Rounds.
          System.out.println(xrounded);    // This Will Now Print Out The Rounded, Random Number.
     }
}

Random random = new Random();
double percent = 10.0; //10.0%
if (random.nextDouble() * 100D < percent) {
    //do
}

Die Hauptidee von Zufall ist, dass es einen Pseudozufallswert zurückgibt. Es gibt keine vollständig zufälligen Funktionen, daher geben 2 zufällige Instanzen, die denselben Startwert verwenden, unter bestimmten Bedingungen denselben Wert zurück.

Es wird empfohlen, zuerst das Funktionsdokument anzuzeigen, um es zu verstehen ( https://docs.oracle.com/javase/8/docs/api/java/util/Random.html) ).

Nachdem wir nun verstanden haben, dass der zurückgegebene Wert der Funktion nextDouble () ein Pseudozufallswert zwischen 0,0 und 1,0 ist, können wir ihn zu unserem Vorteil verwenden.

Um eine Zufallszahl zwischen A und B zu erstellen, die angibt, dass die Grenzen gültig sind (A> B), müssen wir: 1. den Bereich zwischen A und B ermitteln, damit wir wissen, wie viele "Schritte" wir haben. 2. Verwenden Sie die Zufallsfunktion, um zu bestimmen, wie viele Schritte ausgeführt werden sollen (da der zurückgegebene Wert zwischen 0,0 und 1,0 liegt, können Sie ihn als "zufälligen Prozentsatz der Erhöhung auswählen" betrachten. 3. Fügen Sie den Versatz hinzu

Nach all dem können Sie sehen, dass Mob Ihnen meiner Meinung nach den einfachsten und gebräuchlichsten Weg dazu gegeben hat

double randomValue = rangeMin + (rangeMax - rangeMin) * r.nextDouble ();

double RandomValue = Offset + (Range) * (randomVal zwischen 0.0-1.0)