Random Number - Generische Formel zwischen zwei INKLUSIVEN Werten

[Zrebna]

Hallo!

Für Minimum (inklusiv) und Maximum (exklusiv) wäre es ja:
Random r = new Random();
int low = 10;
int high = 100;
int result = r.nextInt(high-low) + low;

Das gäbe dann eine random Zahl zw. 10 und 99 aus.

Wie stellt man es an, dass der Output auch für den Max-Wert inklusiv ist? Also hier:
Random Zahlen zw. 0 und 100?

Lg,
Zrebna

 

[httpdigest]

int high = 100 + 1;

 

[Xyz1]

So geht das: ThreadLocalRandom.current().nextInt(min, max + 1);.

 

[Zrebna]

Top, Danke für die schnelle Hilfe!

 

[temi]

So geht das: ThreadLocalRandom.current().nextInt(min, max + 1);.

Bringt ThreadLocalRandom Vorteile ggü. Random?

 

[Xyz1]

Nein, aber es is eben ab Java 7/8 vorhanden

 

[Zrebna]

Nein, aber es is eben ab Java 7/8 vorhanden

Gibt es da auch was mit oder bzgl. SecureRandom?

 

[temi]

Gibt es da auch was mit oder bzgl. SecureRandom?

Naja, SecureRandom halt. Was ist noch mal die Frage?

https://docs.oracle.com/javase/8/docs/api/java/security/SecureRandom.html

 

[Zrebna]

also gibt es sowas, wie ThreadLocalSecureRandom.current().nextInt(min, max + 1); , war die Frage - scheinbar schon.
hat sich dann erledigt, danke.

 

[Xyz1]

Ich find's etwas unschön

 

[Zrebna]

Ja, ich auch ehrlich gesagt - werde dafür das "normale" SecureRandom verwenden - kp, was da in der Praxis best Convention ist bzw. von professionellen Entwicklern bevorzugt verwendet wird.

 

[mrBrown]

Ja, ich auch ehrlich gesagt - werde dafür das "normale" SecureRandom verwenden - kp, was da in der Praxis best Convention ist bzw. von professionellen Entwicklern bevorzugt verwendet wird.

Für alles „normale“ auch das normale Random nutzen

SecureRandom nur, wenn es wirklich sicher sein muss, braucht man aber direkt in den wenigsten (bzw die meisten Entwickler in keinen) Fällen.

 

[Zrebna]

Für alles „normale“ auch das normale Random nutzen

SecureRandom nur, wenn es wirklich sicher sein muss, braucht man aber direkt in den wenigsten (bzw die meisten Entwickler in keinen) Fällen.

Das ist interessant, denn ist nutzt man SecureRandom nicht dann, wenn man es "wirklich" random haben will?
Ich kann mich nur noch trübe an die relevante Programmier2-Vorlesung im letztem Semester einnern, aber bei "normalem" Random kann man ja nicht eine wirkluche Zufällligkeit erzeugen, weil ich in Wirklkeit aufgrund übergebnem Seed (bound) irgendwann mal ein bestimmter Zyklus wiederholen wird, oder so ähnlich? Und es dann eben nicht mehr wirklich random ist?

 

[mrBrown]

Ja, mit dem normalen Random ist es nicht völlig zufällig - aber für die meisten Anwendungen zufällig genug und in vielen Fällen ist der Seed sogar praktisch.

Wirklich zufällige Zufallszahlen braucht man fast nur dann, wenn’s in Richtung Kryptographie geht, und dann ist man meist besser dran, wenn man es nicht selbst macht.

 

[Flown]

Naja alle Randoms sind PRNG (pseudo random number generators). Die Frage ist, ob du es simpel haben möchtest, oder ob es den cryptographical guidlines entsprechen muss. Die JavaDoc ist doch eh super, warum wie man was nehmen muss.

 

[Xyz1]

Echte Zufälligkeit hast Du nur bei physikalischen Zufallsgeneratoren, also z. B. bei USB-Zufallsgeneratoren die man bei eBay oder Amazon bestellen kann worauf ich mich aber nicht immer verlassen würde die ihre Eingabe aus der Umgebung beziehen (z. B. Hintergrundrauschen des Universums). In der Regel reicht aber ein PRNG. Nun hast Du nach Random vs. SecureRandom gefragt: https://www.geeksforgeeks.org/random-vs-secure-random-numbers-java/ In der Praxis wiederholt sich die Folge nach 2^48 und 2^128 Attempts. Das sollte in den meisten Fällen genügen.

import java.nio.ByteBuffer;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;

public class MyRand {
    private static final Random r1 = new Random();
    private static final SecureRandom r2 = new SecureRandom();
    static {
        // This is may be unnecessary...
        long l1 = r1.nextLong();
        byte[] l2 = SecureRandom.getSeed(Long.BYTES);
        ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES * 2);
        buffer.putLong(l1);
        buffer.put(l2, 0, l2.length);
        buffer.flip(); // need flip
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] encodedhash = digest.digest(buffer.array());
            r2.setSeed(encodedhash);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }

    public static double getRandomDouble() {
        return r1.nextDouble();
    }

    public static double getSecureRandomDouble() {
        return r2.nextDouble();
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(getRandomDouble() + " " + getSecureRandomDouble());
        }
    }
}

Vielleicht macht mein static-Block auch alles nur noch schlimmer.

 

[Zrebna]

Alles klar, alles sehr interessaant - jedenfalls danke an alle Antworten für den Input!