# Random Numbers in Java



## dayaftereh (18. Nov 2009)

Hallo,

Ich bin gerade am überlegen wie man eine eigene Methode bauen kann die eine Zufällige Zahl zwischen 1 und 6 ausgibt! Natürlich kann man es mit :
	
	
	
	





```
int zahl =  1 + (Math.random()*5);
```
 mache, aber ich will das ganze selbst machen. Meine erste Idee ist es über die System.currentTimeMillis()  und Monolo von 6. Aber ich bekomme dann in eine Millisekunde immer die gleiche zahl. Ich könnte noch Salz dazu werfen, aber mir fehlt da einfach der Ideen Ansatz. Mit meiner Idee könnte es auch passieren wenn man die System zeit zurück stellt und dann würfelt, das man eine Zahl bekomme die schon war!

Danke schon mal

Hoffe jemand hat eine Idee


----------



## Der Müde Joe (18. Nov 2009)

>Zahl zwischen 1 und 6 ausgibt! 


```
Random random = new Random(); //benutzt als seed schon Sys.currentMillis
return random.nextInt(6); + 1
```

;-)

Random generator selber zu schreiben ist nicht ganz so trivial ;-)

EDIT:
Vielleicht hiflt diese SEite?
RANDOM.ORG - True Random Number Service


----------



## SlaterB (18. Nov 2009)

System.nanoTime() liefert noch genaueres,
wenn du dann per Thread.sleep() 100 ms schläfst, kann wohl nicht mehr vorausgesehen werden, wieviel Zeit zwischendurch vergangen ist,
allerdings möchte man auch nicht so lange warten,
mache was anderes zwischendurch, paar Objekte erzeugen, auf die Festplatte zugreifen, das dürfte auch etwas zufällige Zeit vergehen lassen

generell ist es natürlich effektiver, nur eine derartige Zufallszahl als Seed irgendwo herzubekommen und danach die Folgezahlen direkt zu berechnen

siehe etwa Random-Klasse in Java

```
/**
     * Generates the next pseudorandom number. Subclasses should
     * override this, as this is used by all other methods.
     *
     * <p>The general contract of {@code next} is that it returns an
     * {@code int} value and if the argument {@code bits} is between
     * {@code 1} and {@code 32} (inclusive), then that many low-order
     * bits of the returned value will be (approximately) independently
     * chosen bit values, each of which is (approximately) equally
     * likely to be {@code 0} or {@code 1}. The method {@code next} is
     * implemented by class {@code Random} by atomically updating the seed to
     *  <pre>{@code (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1)}</pre>
     * and returning
     *  <pre>{@code (int)(seed >>> (48 - bits))}.</pre>
     *
     * This is a linear congruential pseudorandom number generator, as
     * defined by D. H. Lehmer and described by Donald E. Knuth in
     * <i>The Art of Computer Programming,</i> Volume 3:
     * <i>Seminumerical Algorithms</i>, section 3.2.1.
     *
     * @param  bits random bits
     * @return the next pseudorandom value from this random number
     *         generator's sequence
     * @since  1.1
     */
    protected int next(int bits) {
```


----------



## Der Müde Joe (18. Nov 2009)

zum Modulo:
Effective Java Programming Language Guide: Random Thoughts


----------



## dayaftereh (18. Nov 2009)

Wie gesagt ich will keine Vordefinierte Klasse / Methode nutzen, sondern es komplett selbst machen. Ja nanoTime wer eine Idee, aber wenn ich die zeit zurück stelle bekomme ich die gleichen Würfe!


----------



## SlaterB (18. Nov 2009)

du kannst unmöglich die Zeit so zurückstellen, dass in einem Programm ein nano-Aufruf exakt dasselbe liefert,
und wie gesagt: etwas Zufall selber einbauen, Thread.sleep(), Objekte erstellen, ..


----------



## kirdie (18. Nov 2009)

Möchtest du (1) wirklich zufällige Werte oder (2) nur einen Pseudozufallsgenerator?

(1) Wenn du ein deterministisches Weltbild hast, dann ist dies garnicht möglich (alles ist vorherbestimmt).
Wenn nicht, dann sind wirklich zufällige Prozesse z.B. bestimmte Quanteneffekte und der nukleare Zerfall.
Also z.B. einen Geigerzähler an den PC schließen und die Abstände zwischen den Impulsen als seed nehmen.
Auch das weiße Rauschen, dass du mit einer Antenne auf einer Frequenz empfängst, auf der kein Sender sendet ist glaub ich echt zufällig.
Oder du nimmst eine Webcam und nimmst das Rauschen (also die hohen Frequenzen) daraus.
Was du auch machen kannst, ist einen halbdurchlässigen Spiegel nehmen und ein einziges Photon durchschicken. Wenn das Photon durchgeht, nimmst du das als 0, wird es reflektiert, als 1 

(2)
Das mit der Zeit und dem Modulo ist doch eine gute Idee. Bei Röhrenmonitoren kannst du ihmo auch die Position des Zeilenstrahles nehmen (aber da brauchst du sicher eine Bibliothek aus einer hardwarenäheren Programmiersprache).


----------



## Riedelinho (18. Nov 2009)

//edit


----------

