# int nextInt(int n) Methode



## Unkownsyntax (4. Jun 2009)

Hi hier mal der Code von der Methode:

```
public int nextInt(int n) { 
     if (n<=0) 
         throw new IllegalArgumentException("n must be positive"); 
 
     if ((n & -n) == n)  // i.e., n is a power of 2 
         return (int)((n * (long)next(31)) >> 31); 
 
     int bits, val; 
     do { 
         bits = next(31); 
         val = bits % n; 
     } while(bits – val + (n-1) < 0); 
     return val; 
}
```

Und hier mal die Aufgabenstellung:
Die Funktionsweise des zugrundeliegenden Algorithmus wird in der Dokumentation 
aber nur unvollständig erklärt. 
Analysieren Sie den Algorithmus und erklären Sie seine Funktionsweise im Detail 
(Anweisung für Anweisung). Beantworten Sie dabei unter anderem folgende Fragen: 

• Warum kann man in Java mit der Bedingung (n&-n)==n prüfen, ob ein, wenn n eine Zweierpotenz ist? 
• Was wird zurückgegeben, wenn n eine Zweierpotenz ist? Wie funktioniert die Berechnung in der return-Anweisung genau?

• Warum kann zum Berechnen der Zufallszahl im gewünschten Wertebereich in der Schleife eine Modulo-Operation verwendet werden?

• Wie wird sichergestellt, dass die Zufallszahlen gleichverteilt sind? Gehen Sie dabei insbesondere auf die Bedingung der do-while-Schleife ein. 

Die Darstellung von negativen Zahlen in Java (Zweierkomplement-Darstellung) spielt eine wichtige Rolle. 






Was mir mal klar ist dass bei der ersten if anweisung wo n=0 steht eine Exception gworfen wird. Dass n positiv sein muss.
Bei der nächsten if Anweisung steht wenn n&-n = n ist (was glaub ich nur sein kann bei 2^n zahlen oder?)
Soll er einen Int Wert zurückgeben aber welchen genau was das genau bedeutet weiß ich nicht verschiebe operator ist noch drinnen und so....?
Danach Deklaration von zwei int werten.
Danach eine do while schleife wo zwei zuweisungen sind eine mit einen modulo operator aber was die genau bedeuten weiß ich nicht und wie lange die schleife erfüllt ist die abbruchbedingung versteh ich auch nicht ganz.
Was heißt das next(31) versteh ich nicht?

Auf die Zusatzfragen hab ich auch nicht wirklich eine antwort. 

Bitte um Hilfe


----------



## SlaterB (4. Jun 2009)

kurz gefasst verstehst du eigentlich gar nix wichtiges von dem Programm 
wenn du schon nichtmal weißt, was next(31) ist, dann kannst ja auch nicht weiterkommen,

sowas müsste eigentlich dabei stehen oder sich auf eine vorherige Aufgabe beziehen, 
hast du vielleicht eine Umgebung, in der du den Code testen kannst?

die normale und hier anscheinend auch gemeinte Bedeutung ist: erzeuge eine Zufallszahl mit 31 Bit als int, 
das 32. Bit ist das Vorzeichen, wenn das gesetzt ist, wird der int negativ, daher fällt das weg

> Bei der nächsten if Anweisung steht wenn n&-n = n ist (was glaub ich nur sein kann bei 2^n zahlen oder?)

geschickte oder naive Frage, 
dass das nur bei 2er-Potenzen sein kann sollst du ja gerade erst erklären!
dazu musst du wissen, wie Java positive und negative Zahlen darstellt, 
lies das irgendwo nach oder benutze auch Integer.toBinaryString(int)

schau dir genau an, wie derartige Zahlen und ihre Komplemente aussehen und wie das & davon sein wird

> was das genau bedeutet weiß ich nicht verschiebe operator ist noch drinnen und so....?

so kommst du nicht zum Ziel, 
was >> ist musst du ganz exakt wissen um hier weiter zu machen 
-> Lehrbuch, falls noch nicht bekannt

und wie zuvor: Beispiele anschauen,
nimm dir paar 2er-Potenzen wie 2^5 oder 2^15, überlege dir außerdem, was next(31) genau für Zahlen liefern kann,
und dann heißt es Denken,
das Denken kann dir keiner abnehmen, das ist deine Aufgabe 

über die while-Schleife könnte man später noch nachdenken, das ist nochmal etwas höher


das ist übrigens genau der Code von nextInt(int) der Klasse Random, 
vielleicht willst du da in der Doku bisschen abgucken,
hier noch ein Testprogramm zum ausprobieren:


```
public class Test extends Random {

	public int nextInt(int n) {

		if (n <= 0)
			throw new IllegalArgumentException("n must be positive");

		if ((n & -n) == n) // i.e., n is a power of 2
			return (int) ((n * (long) next(31)) >> 31);

		int bits, val;
		do {
			bits = next(31);
			val = bits % n;
		} while (bits - val + (n - 1) < 0);
		return val;
	}

	public static void main(String[] args) {
		System.out.println(new Test().nextInt(32));
	}
}
```


----------

