genereer een willekeurige dubbele in een bereik

Ik heb twee doubles zoals het volgende

double min = 100;
double max = 101;

En met een willekeurige generator, moet ik een dubbele waarde creëren tussen het bereik van MIN en MAX.

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

Maar er is niets hier waar we het bereik kunnen opgeven.

Antwoord 1, Autoriteit 100%

Om een ​​willekeurige waarde te genereren tussen rangeMinen rangeMax:

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

Antwoord 2, Autoriteit 59%

Deze vraag werd gesteld vóór Java 7-release, maar nu is er een andere mogelijke manier met behulp van Java 7 (en boven) API:

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

nextDoubleretourneren een pseudorandom dubbele waarde tussen het minimum (inclusief) en het maximum (exclusief). De grenzen zijn niet noodzakelijk inten kunnen doublezijn.

Antwoord 3, Autoriteit 18%

Gebruik dit:

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

bewerken:

new Random().nextDouble(): genereert willekeurig een getal tussen 0 en 1.

start: startnummer, om nummer “naar rechts” te schuiven

end - start: interval. Willekeurig geeft je 0% tot 100% van dit getal, want willekeurig geeft je een getal van 0 tot 1.

BEWERK 2:
Tks @daniel en @aaa bbb. Mijn eerste antwoord was fout.

Antwoord 4, autoriteit 2%

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.
     }
}

Antwoord 5

Ik hoop dat dit het beste kan helpen: Random Number Generators in Java

Een compleet programma delen:

import java.util.Random;
public class SecondSplitExample
{
    public static void main(String []arguments)
    {
        int minValue = 20, maxValue=20000;
        Random theRandom = new Random();
        double theRandomValue = 0.0;
        // Checking for a valid range-
        if( Double.valueOf(maxValue - minValue).isInfinite() == false ) 
            theRandomValue = minValue + (maxValue - minValue) * theRandom.nextDouble();
        System.out.println("Double Random Number between ("+ minValue +","+ maxValue +") = "+ theRandomValue);
    }
}

Hier is de output van 3 runs:

Code>java SecondSplitExample
Double Random Number between (20,20000) = 2808.2426532469476
Code>java SecondSplitExample
Double Random Number between (20,20000) = 1929.557668284786
Code>java SecondSplitExample
Double Random Number between (20,20000) = 13254.575289900251

Meer informatie:

• Top 4 manieren om willekeurige getallen te genereren in Java
• Random:Docs

Antwoord 6

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

Antwoord 7

Het belangrijkste idee van willekeurig is dat het een pseudowillekeurige waarde retourneert.
Er bestaat niet zoiets als volledig willekeurige functies, daarom zullen 2 willekeurige instanties die dezelfde seed gebruiken onder bepaalde omstandigheden dezelfde waarde retourneren.

Het is een goede gewoonte om eerst het functiedocument te bekijken om het te begrijpen
(https://docs.oracle.com/javase /8/docs/api/java/util/Random.html)

Nu we begrijpen dat de geretourneerde waarde van de functie nextDouble() een pseudowillekeurige waarde tussen 0,0 en 1,0 is, kunnen we deze in ons voordeel gebruiken.

Voor het maken van een willekeurig getal tussen A en B, op voorwaarde dat de grenzen geldig zijn (A>B), moeten we:
1. zoek het bereik tussen A en B, zodat we kunnen weten hoeveel “stappen” we hebben.
2. gebruik de willekeurige functie om te bepalen hoeveel stappen u moet nemen (omdat de geretourneerde waarde tussen 0,0 en 1,0 ligt, kunt u dit zien als “kies een willekeurig stijgingspercentage”
3. voeg de offset toe

Daarna kun je zien dat maffia je naar mijn mening de gemakkelijkste en meest gebruikelijke manier heeft gegeven om dit te doen

dubbele randomValue = rangeMin + (rangeMax – rangeMin) * r.nextDouble();

dubbele willekeurige waarde = offset + (bereik)*(willekeurige waarde tussen 0,0-1,0)