# Random Zahlen



## Guest (6. Feb 2009)

Hallo 

ich habe folgenden Code


```
public java.util.Random rdm(){
		java.util.Random test = new java.util.Random();
		test.nextInt(999999999);
		return test;
	}
```

Nun meine erste Frage dazu:
Wie bekomme ich den wert den er da Random erzeugt raus? Also was ich genau meine ist ich will im Prinzip den wert haben. Folgendes habe ich bereits ausprobiert:
Also weis nicht mehr genau was ich gemacht habe kann auch sein das es die zweite Variante war die ich geschrieben habe.


```
data.getTest().toString();
```


```
data.rdm().toString;
```

Wenn ihr es nochmal genau wissen wollt mus sich das halt nochmal ausprobieren und kann euch dann sagen was ich genau geschrieben habe. Auf jedenfall bekarm ich dann folgendes:



> java.util.Random@1ee3914



Genauer habe ich das alles in einen StringBuffer gepackt wo auch noch paar andere werte drin stehen. Dieser wurde dann in eine Datei ausgegeben. 

Meine nächste Frage ist es möglich Random auch für Buchstaben zu benutzen? Also das ich einen Buchstabensalat rausbekomme?

Und noch eine Frage ich muss teilweise Zahlen mit 13 zeichen erzeugen, jedoch weis ich noch nicht wie das gehen soll, da Int ja nur bis ka 2000000000 oder so geht also 9 Zahlen. Und auserdem bei dem Buchstabensalat muss ich bis zu 27 zeichen bekommen. 

Vielen Dank im voraus für die Hilfe.


----------



## hdi (6. Feb 2009)

Random ist ein Objekt, sozusagen nur die "Maschine", die dir eine zufällige Zahl hergibt.

mit Random test = new Random() baust du dir die Maschine.
mit test.nextInt(...) drückst du auf einen Knopf "Zufallszahl erzeugen".
Wenn du da drauf drückst kommt unten eine Zahl raus. 
Die musst du ankucken.

Um es mal etwas weniger blöd zu schreiben:


```
int zufallszahl = test.nextInt();
System.out.println(zufallszahl);
```

.nextInt() ist also nur eine Methode, diese generiert und returned (!) dir eine Zahl.
Wenn du sie nicht abspeicherst, ist sie halt verloren.

mit

System.out.printl(test);

druckst du dir das Random-Objekt, also die Maschine. Und die hat nun mal irgendeinen bescheuerten Namen.


----------



## Gast (6. Feb 2009)

nextInt() gibt dir ein int zurück
Deine Methode hat kein Rückgabewert. Sollte dann wohl auch int sein.
Bei return dann den int returenn, nicht die Referenz auf das Random Objekt.


----------



## Guest (6. Feb 2009)

Danke schonmal für den tipp mit dem int zufallszahl.
Jetzt habe ich folgenden Text den er aber auch nicht mag:


```
public java.util.Random rdm(){
		java.util.Random test = new java.util.Random();
		int zufallszahl = test.nextInt(2099999999);
		return zufallszahl;
	}
```

Da streicht er mir dann die zufallszahl rot an und sagt:



> Type mismatch: cannot convert from int to Random



Was muss ich denn jetzt machen damit er mit dem zufrieden ist? Bzw. gebe ich bei dem return test an dann kann ich irgendwie die zufallszahl nicht aufrufen.

Und solltet ihr Zeit finden um meine restlichen fragen die ich im ersten Post geäusert habe zu beantworten wäre das auch sehr nett.


----------



## Gast (6. Feb 2009)

Deine Methode erwartet derzeit ein return von einer Referenz auf ein Random Objekt. Das musst du auf int ändern (Methodenkopf)


----------



## Der Müde Joe (6. Feb 2009)

public java.util.Random rdm(){ 

--->
public int rdm(){


----------



## hdi (6. Feb 2009)

mal so nebenbei: Ich hab's jetzt nicht ausgerechnet aber bei int musst du mit den Werten aufpassen,
du kannst da nicht beliebig grosse Zahlen eingeben.

Genau genommen hat int 4 byte, also 32 bit, also 2^32 verschiedene Zahlen.

Wenn du grössere Zahlen eingeben willst, brauchst du den Datentyp long.


----------



## Guest (6. Feb 2009)

Ok Danke nochmals ^^. Nächster Punkt. Jetzt will ich den wert haben und sage meinem Programm folgendes


```
data.rdm().toString()
```

Eclipse unterstreicht mir dies wieder rot mit folgender meldung:



> Cannot invoke toString() on the primitive type int



Dabei habe ich das doch vorher auch so gemacht. Warum gehts jetzt nicht mehr?

@ hdi: Es war mir bewusst das ich nicht genügend zeichen zusammen bekommen würde ^^ und deshalb habe ich ja auch in meinem ersten Post danach gefragt was ich da tun könnte. Danke für die Antwort ich werde es probieren.


----------



## hdi (6. Feb 2009)

toString() ist eine Methode die jedes Objekt der Standard API hat.

Und Objekte (String, JButton, und der Rest der API) != Primitive (int, double, boolean, char, long)

Diese haben keine solche Methode, sie werden aber automatisch in eine Text-Darstellung umgewandelt,
wenn das nötig ist:


```
int x  = 5;
System.out.println(x); // Java wandelt hier den int automatisch in einen String um
```

Natürlich nur temporär für den Aufruf dieser Methode. Dein x ist danach natürlich noch immer ein int.


----------



## Guest (6. Feb 2009)

Heist folgich ich kann das toString() weglassen. 
Wie müsste die Methode denn aussehen wenn ich ein nextLong machen will. Er sagt mir da nämlich irgendwie das das nicht geht obwohl das nextLong in der API von Random mit drinne steht. 


```
public String rdm(){
		java.util.Random test = new java.util.Random();
		String zufallszahl = test.nextLong(2099999999);
		return zufallszahl;
	}
```

So hab ichs jetzt gemacht weil ich den wert in String haben "MUSS" und er sagt mir bei nextLong



> The method nextLong() in the type Random is not applicable for the arguments (int)



Dabei habe ich doch garnichts mit int gemacht oder?


----------



## hdi (6. Feb 2009)

Wenn du nochmal in die API kuckst wirst du sehen, dass die Methode nextLong() gar keinen Parameter erwartet.
Der Grund dafür ist dass longs eh so unheimlich gross sind, dass es keinen Sinn macht eine bestimmte Grenze
anzugeben.

PS: Es hilft, sich mehr mit den Fehlermeldungen auseinander zu setzen. Kannst du Englisch?
Eigentlich lassen die Meldungen immer ganz gut erahnen, was da das Problem ist.

PPS: Direkt in einen String speichern kannst du Primitive aber nicht! Das wird wie gesagt nur bei bestimmten
Methoden automatisch gemacht! Du rufst hier aber keine solche Methode auf, sondern willst es direkt
als String "reinpressen". Das geht nicht, es geht nur so:


```
String = 10 + "";
```

Das "" ist für Java ein (leerer) String. Strings "binden" stärker als Primitive, daher wird das + hier nicht
als Addition interpretiert, sondern als Konkatenation (Aneinenaderreihung). Er will also an den leeren
String "" einen anderen String ranhängen. So, und JETZT wandelt er den int wieder automatisch um.

Ist bisschen gewöhnungsbedürftig, das muss man einfach auswendig lernen.


----------



## Guest (6. Feb 2009)

ich muss aber eine Grenze angeben weil es auch nicht zu lang werden darf. Gibt es dafür eine andere möglichkeit als den rest abzuschneiden? 
Ich bin mir zwar sicher das man das einfach abschneiden kann, aber kann mir garnicht vorstellen wie ich das machen soll. Deshalb frage ich grad nach einer einfacheren methode.


----------



## hdi (6. Feb 2009)

```
long zahl = test.nextLong();
long maximalWert = 500000000;
if (zahl > maximalWert){
     zahl = maximalWert;
}
```

...ich weise dich nochmal auf meinen letzten Beitrag hin, ich hab da was editiert, das solltest
du lesen.


----------



## hdi (6. Feb 2009)

Ach nochwas:

Das schneidet dir jetzt nix auf eine bestimmte Stelle ab, sondern limitiert nur den Wert. 
Es kann gut sein dass du jetzt sehr oft den Maximalwert rauskriegst (je nachdem wie niedrig du ihn setzt).

Von daher ist es vllt wirklich besser, es als String zu speichern (s.o.) und dann den String
abzuschneiden:


```
while( zufallsZahl.length > 10 ) // solange es mehr als 10 Stellen sind
{
      zufallsZahl = zufallsZahl.substring(0,zufallsZahl.length); // ersetzen durch den Teilstring von Anfang bis Ende-1
}
```


----------



## Guest (6. Feb 2009)

Ok also das mit dem Maximal wert habe ich hinbekommen jetzt scheitere ich wieder am abschneiden den Maximal wert habe ich wieder auskommentiert. Bei dem was du mir jetzt grad gezeigt hast komme ich nicht mehr mit. Also ich habs einfach mal eingefügt:


```
public String rdm(){
		java.util.Random test = new java.util.Random();
		long zufallszahl = test.nextLong();

//		long maximalWert = 500000000; 
//		if (zufallszahl > maximalWert){ 
//		     zufallszahl = maximalWert; 
//		}
//		String zahl = zufallszahl + ""; 

		while( zufallszahl.length > 10 )
		{ 
		      zufallszahl = zufallszahl.substring(0,zufallszahl.length);
		}
		
		return zahl;
	}
```

Erstmal wie Funktioniert das? Und dann hat er mir wieder rot gezeigt ^^:



> The primitive type long of zufallszahl does not have a field length


----------



## hdi (6. Feb 2009)

Naja mein Code geht wie gesagt davon aus, dass du den long als String speicherst:


```
String zufallszahl = test.nextLong() + "";
```

String bietet eine Methode substring(int begin, int end), die den String, auf den sie angwandt wird,
hernimmt und einen neuen String erstellt der ein Teil dieses Strings ist.

Man muss 2 Dinge beachten:

1) Die Zählung beginnt bei 0. D.h. die erste Stelle ist nicht 1 sondern 0
2) was du bei "end" übergibst, ist exklusiv. D.h. er nimmt nur bis zur Stelle (end-1) rein.

Bsp:


```
String s = "Hallo";
s.substring(0,2); // <- gibt "Ha"
```

... kennst du überhaupt die _Punkt-Notation_? Also das s.methode ?

Ich will dich ja jetzt nicht zuschütten, Strings sind eh ne Sache für sich.

So musst du zB auch:


```
s = s.substring(x,y)
```

machen und nicht


```
s.substring(x,y)
```
weil Strings "Immutable" sind, aber ich glaub das geht jetzt zuweit.

Hm.. aber so geht's halt xD Kanns dir gerne noch genauer erklären, hast du es soweit schon mehr
verstanden? Kennst du überhaupt while-Schleifen  :autsch:


----------



## Guest (6. Feb 2009)

Also eine für mich nützliche sache konnte ich schonmal rausziehen ^^. Nämlich den ersten Code den du eben geschrieben hast ^^. Aber wie ich das jetzt mache, das es funktioniert weis ich leider nicht. Ich habs wohl nicht ganz verstanden. Also theoretisch weis ich alles nur kann ich es nicht programmieren. Soll heisen ja ich weis was eine while schleife ist ^^. 
Ich muss jetzt leider zum Mittag ^^. Heist werde ne std lang nichts von mir hören lassen. Wäre aber nett, wenn du nicht zufällig auch grad mittag machst, wenn du mir das dann doch nochmal erklären könntest ^^. Also spezifisch was ich schreiben muss und warum ich es schreiben muss. Hauptsächlich meine ich das was zum abschneiden gedacht ist das habe ich noch nicht verstanden. 

Also dann bis später.


----------



## Guest (6. Feb 2009)

So bin wieder da nehme an du hast auch grad mittag gemacht? Weil du noch nicht geantwortet hast.


----------



## Fu3L (6. Feb 2009)

hdi hat gesagt.:
			
		

> PPS: Direkt in einen String speichern kannst du Primitive aber nicht! Das wird wie gesagt nur bei bestimmten
> Methoden automatisch gemacht! Du rufst hier aber keine solche Methode auf, sondern willst es direkt
> als String "reinpressen". Das geht nicht, es geht *nur* so:
> 
> ...



Es gibt schon so eine Art toString() Methode für primitives:


```
String zahl = Integer.toString(222);
```

Halt die statischen toString() Methoden der Wrapper-Klassen und dann auch noch die String.valueOf() Methoden:


```
String zahl = String.valueOf(222);
```

Find ich persönlich schöner, wenn man nicht sowieso schon einen String zusammenbastelt...


----------



## hdi (6. Feb 2009)

Na wollen wir ihn mal nicht überfordern, das ganze artet ja eh schon aus.

@TC

Was genau verstehst du nicht? Okay du weisst was eine while-Schleife ist, und wie schaut's
mit dem Punktoperator aus? Sag mir einfach Schritt für Schritt, was du jetzt noch nicht
verstehst.

Zum Abschneiden:

Ich kann eigentlich nicht mehr sagen als nochmal das im letzten Post. Vllt nochmal ein Bsp:


```
String test = "Hallo";
test.substring(0,1);
```

Das substring(0,1) nimmt den String "test" und macht einen neuen String, der vom String test alle
Zeichen ab einschliesslich der Stelle 0 ("H") enthält, bis ausschliesslich die Stelle 1 ("a"):

Weil letzteres exklusiv ist, kommt also nur "H" heraus.

Und was ich auch noch nicht erklärt habe:

"length()" ist eine Methode für Strings, die deren Länge zurückgibt.

Folglich ist also:


```
s.substring(0,s.length);
```

ein Teilstring von dem String s, der alle Zeichen von s enthält, bis auf das letzte! Siehe dazu meinen
Beiträg weiter oben irgendwo: Der zweiter Parameter ist ein exklusiver Index!

Man muss das eben nur verstehen, dass Java bei 0 anfängt zu zählen und nicht bei 1.


----------



## Guest (6. Feb 2009)

Schade das du dich erst jetzt wieder meldest mache nämlich bald feierarbend komme aber montag wieder keine sorge ^^. Also Punktoperator weis ich jetzt nicht so was gemeint ist. was ich nicht verstehe wie das abschneiden funktioniert. also was da gemacht wird und warum er bei mir folgendes rot anstreicht mit der darauf folgenden fehlermeldung


```
while( zufallszahl.length > 10 )
		{ 
		      zufallszahl = zufallszahl.substring(0,zufallszahl.length);
		}
```



> zufallszahl.length cannot be resolved or is not a field



sry aber hatte nen anstrengenden tag deshalb mach ich jetzt auch feierabend


----------



## hdi (6. Feb 2009)

das mit dem length war ein Tippfehler meinerseits   

Richtig heisst es:


```
s.length() // das ist nämlich eine Methode
```

Zum Abschneiden kann ich dir nichts weiter sagen. Wenn du dir meinen letzten Post und die 2-3 davor
nochmal anschaust, musst du das eigentlich verstehen. Auch wenn du jetzt erstmal nicht weisst
was der Punkt-Operator macht.

Und wenn du es echt nicht verstehst, dann sag mir was genau du daran nicht verstehst.


----------



## Guest (9. Feb 2009)

thx nochmals das funst jetzt und ich habs fast ganz verstanden


```
while( zufallszahl.length() > 10 )
		{ 
		      zufallszahl = zufallszahl.substring(0,zufallszahl.length());
		}
```

heist im prinzip
Solange ( die länge der zuafallszahl größer 10 ist) {
                setze die zufallszahl = die zufallszahl.substring(begin bei 0, ende beim ende des long());
            }

da fällt mir gerade auf kanns sein das das größer gegen ein kleiner ausgetauscht werden muss?


----------



## Murray (9. Feb 2009)

Anonymous hat gesagt.:
			
		

> ```
> while( zufallszahl.length() > 10 )
> {
> zufallszahl = zufallszahl.substring(0,zufallszahl.length());
> ...


Nein, das heißt im Prinzip:
Solange ( die Länge der Zufallszahl größer 10 ist) {
  Setze die Zufallszahl auf den Abschnitt der Zufallszahl vom ersten bis zum letzen Zeichen
}
Oder auch:
Solange ( die Länge der Zufallszahl größer 10 ist) {
  Setze Zufallszahl auf Zufallszahl
}
Oder auch:
Wenn ( die Länge der Zufallszahl größer 10 ist) {
  Verbrate soviele CPU-Zeit wie möglich mit Nichtstun
}

Das ist also eine Endlosschleife.

Besser:

```
if( zufallszahl.length() > 10 ){ 
		zufallszahl = zufallszahl.substring(0,10);
}
```
Oder - um das redundante Vorkommen der 10 zu eliminieren, was weniger fehlerträchtig ist, wenn Du irgendwann mal nicht mehr 10, sondern 8 oder 12 Zeichen haben willst - auch so:

```
final int maxLen = 10;
if( zufallszahl.length() > maxLen ){ 
		zufallszahl = zufallszahl.substring(0,maxLen);
}
```


----------



## Guest (9. Feb 2009)

Also deins heist jetzt im Prinzip?!:
wenn die zufallszahl größer 10 ist dann mache folgendes:
setze die zufallszahl gleiche der zufallszahl von 0 bis 10

hdi hat mir das schonmal erklärt also da würde ich jetzt trotzdem nur 10 zeichen bekommen oder? hdi hatte mal was gesagt das er ja bei 0 anfängt zu zählen aber bei 10 eins abzieht irgendwie sowas oder?


----------



## Murray (9. Feb 2009)

Anonymous hat gesagt.:
			
		

> Also deins heist jetzt im Prinzip?!:
> wenn die zufallszahl größer 10 ist dann mache folgendes:
> setze die zufallszahl gleiche der zufallszahl von 0 bis 10


Genauer: setze Zufallszahl auf die ersten zehn Zeichen der Zufallszahl



			
				Anonymous hat gesagt.:
			
		

> hdi hat mir das schonmal erklärt also da würde ich jetzt trotzdem nur 10 zeichen bekommen oder?


Das verstehe ich jetzt nicht vollständig, aber ja: so bekommt man 10 Zeichen - ist das nicht das, was Du willst?



			
				Anonymous hat gesagt.:
			
		

> hdi hatte mal was gesagt das er ja bei 0 anfängt zu zählen aber bei 10 eins abzieht irgendwie sowas oder?


Der Startindex für die substring-Methode (also der erste Parameter) ist in der Tat nullbasiert: wenn man also vom ersten Zeichen an anfangen will, dann muss man 0 übergeben. Der zweite Parameter den Methode heißt zwar _endIndex_, gibt aber in Wirklichkeit den nullbasierten Index des erstens Zeichnes an, das gerade eben nicht mehr kopiert werden soll.



			
				Javadoc hat gesagt.:
			
		

> public String substring(int beginIndex,
> int endIndex)
> 
> Returns a new string that is a substring of this string. The substring begins at the specified beginIndex and extends to the character at index endIndex - 1. Thus the length of the substring is endIndex-beginIndex.
> ...


----------

