Int erstellen lassen?

[XWing]

Hallo,

habe eine kleine frage. Ist es möglich das man durch eine for schleife int generieren kann? Sprich durch zb ein blackjack, wird jedes mal ein neuer int mit einem zufälligem wert generiert und als karte 1,2.... oder so definiert wird wenn die gesamtzahl der karten unter 21 ist. Oder kann man durch eine for schleife einfach imer werte generieren lassen und sie speichern? Sie es jetzt ohne jedes mal einen int zu erstellen oder in einer arrayliste oder sowas.

 

[KonradN]

Ja natürlich, Du hast eine mögliche Lösung bereits selbst genannt: ArrayList.

Da Du in einer ArrayList nur Referenzen speichern kannst, speicherst Du aber keine int Werte sondern Referenzen zu Integer (dem Wrappertyp von int).

Du kannst also etwas machen wie:

        ArrayList<Integer> myValues = new ArrayList<>();
        for (int i= 0; i < 5; i++) {
            int random = (int) (Math.random() * 100);
            myValues.add(random);
        }

(Nur um kurz einfach mal etwas Code zu zeigen - hier eine einfache Schleife, in der 5 zufällige Zahlen erzeugt und in einer ArrayList gespeichert werden.)

 

[XWing]

Okay cool, danke.

 

[mihe7]

Kleine Ergänzung: statt Math.random() kann man beispielsweise auch die Klasse java.util.Random an, die ein paar praktische Methoden enthält. Beispielsweise eine Methode nextInt, die ganzzahlige Zufallszahlen innerhalb definierten Grenzen liefert. Damit wird der Code von @KonradN zu:

        ArrayList<Integer> myValues = new ArrayList<>();
        Random rand = new Random();
        for (int i= 0; i < 5; i++) {
            int random = rand.nextInt(100);;
            myValues.add(random);
        }

Des weiteren definiert die Klasse eine Methode ints, die einen Stream von Zufallszahlen liefert. Damit lässt sich der Code als Einzeiler beispielsweise wie folgt schreiben:

ArrayList<Integer> myValues = new ArrayList<>(new Random().ints(5, 0, 100).boxed().toList());

Kurz zur Erklärung: new Random() erzeugt ein neues Random-Objekt. Auf diesem wird die ints-Methode aufgerufen, um einen Stream mit 5 ganzzahligen Zufallszahlen im Intervall [0; 100[ (rechts offen, also ohne 100) zu erzeugen. Da es sich bei den Elementen um primitive int-Werte handelt, wandeln wir diese per boxed in Integer-Objekte um. Sodann lassen wir uns die Elemente per toList() als Liste ausgeben. Das Ergebnis ist vom Typ java.util.List, da wir aber eine ArrayList haben möchten, erstellen wir eine solche und verwenden dabei das Ergebnis einfach als Parameter des ArrayList-Konstruktors.

Weil Blackjack und Karten erwähnt wurden: wenn es um ein Mischen geht, sollte man anders vorgehen, schließlich sollen am Ende ja genau die gleichen Elemente in der Liste enthalten sein wie vor dem Mischen, nur in anderer Reihenfolge. Freundlicherweise bietet Java für das Mischen von Collections eine Methode Collections.shuffle an.

 

[XWing]

Kleine frage noch wie kann man die ganzen werte zusammenrechen? Weil die einzige methode die mir einfällt wäre:

zahl + zahl

Und ich möchte keine Kartenmischen. Im endefekt möchte ich versuchen ein Blackjack eine ui zu geben. Dafür möchte ich gerade aber erstaml ein Blackjack erstellen was man in denn commands benutzen kann um es denn letztendlich ein ui zu geben. Und nach der ui wolte ich versuchen das blackjack und mein anderes flagenspiel in eine ui zu bekommen als übung oder so oder damit ich einfach weiß wies geht.

Danke für die Antworten.

 

[Oneixee5]

old-fashioned:

var listOfNumbers = List.of(1,2,3,4,5,6,7,8,9,10);

var sum = 0;
for (int i = 0; i < listOfNumbers.size() ; i++) {
    sum += listOfNumbers.get(i);
}
System.out.println(sum);

var listOfNumbers = List.of(1,2,3,4,5,6,7,8,9,10);

var sum = 0;
for (int number : listOfNumbers) {
    sum += number;
}

fancy: https://www.baeldung.com/java-stream-sum

 

[XWing]

2 Fragen habe ich wieder.

1. könnte mir jemand genau erklären was die 2 for schlefe macht? Weil ich bin mir jetzt nicht sicher was das var und ":" zu bedeuten hat.

2. Ich habe versucht jetzt beides ein einer for schlefie zu machen, scheint auch zu funktionieren. Ich möchte es jetzt in eine methode packen um es einfacher aufrufen zu können. Aber ab da hackts dann. Ich schaffe es irgendwie nicht dieser methode zu definieren weil intelij immer meckert.

public int zahlen{
         ArrayList<Integer> myValues = new ArrayList<>();
         for (int i = 0; i < 1; i++) {
            int random = (int) (Math.random() * 14);
            myValues.add(random);
            int sum = 0;
            for (int number : myValues) {
                sum += number;
            }
        }
       }

 

[KonradN]

Der Code macht so relativ wenig Sinn. Daher ist wirklich wichtig, dass Du vernünftig an die Software Entwicklung heran gehst. Und da ist der erste Schritt immer, dass man im Detail versteht, was man überhaupt machen will. Dazu wirklich in Worten aufschreiben, was Du überhaupt machen willst.

Wieso macht der Code keinen Sinn?
a) Deine äußere Schleife wird wie oft laufen? => Genau 1 mal - also wozu eine Schleife?
b) Angenommen die Schleife würde mehrfach abgearbeitet: Während Du Zahlen hinzu fügst, addierst Du diese immer wieder?
c) Du ermittelst dann die Summe in sum - und machst dann nichts damit ...
d) IntelliJ meckert? Ja was meckert IntelliJ denn? Die Fehlermeldung sollte genau sagen, was falsch ist. Vermutlich den letzten Punkt, den ich auf Anhieb sehe: Deine Methode zahlen soll etwas zurück geben, aber Du gibst nichts zurück.

 

[XWing]

OK stimmt, sorry.

public ArrayList<Integer> myValues = new ArrayList<>();
    public void zahlen(){
        int Karte = (int) (Math.random() * 15);
        myValues.add(Karte);
    }

    public void addition(){
        int sum = 0;
        for (int number : myValues ) {
            sum += number;
        }
    }

Ich habs jetzt so geschrieben.
Bei Math.random wird ja die zahl 0.0 mal 15 multipliziert um einen zufälligen wert herauszubekommen, so habs ich jetzt verstanden. Aber kann ich das auch eingrenzen. Sprich das nur zahlen von 2-14 generiert werden?

Und wenn ich ich jetzt eine weitere Schleife machen möchte die solange läuft bis man sie abricht oder über 21 kommt. Kann ich da wieder eine for Schleife machen um temporäre ints augeben zu lassen? Im Endeffekt soll es so funktionieren: Die schleife fängt an und man spielt in diesem fall jetzt Blackjack. Und es sollen immer die Karten und der der Gesamtwert der Karten angezeigt werden. Bis jetzt hab ich das immer manuel gemacht. Sprich immer sowas geschrieben wie Karte3 + Karte4 um mir so die einzelnen Werte und denn Gesamtwert auszugeben. Und das halt in 4 Blocks.

Kann man aber jetzt eine for Schleife benutzen um es in eine Schleife zu packen? Also das immer Automatisch ints mit Numerierung ausgeben werden?

Bitte nicht die ganze Schleife dafür angeben sondern nur denn Part womit ich immer neue ints für die ausgabe generieren kann wenns geht. Denn rest möchte ich mir selber erarbeiten.

 

[KonradN]

Aber kann ich das auch eingrenzen. Sprich das nur zahlen von 2-14 generiert werden?

Du musst es Dir einfach einmal überlegen. Du bekommst eine Zahl r mit 0 <= r < 1
Wenn Du da jetzt alles mit x Multiplizierst, dann bekommst Du 0*x <= r*x < 1*x also 0 <= r*x < x
Wenn Du den Bereich 2...14 haben willst, dann ist es die untere Grenze nicht 0 sondern 2, die obere Grenze ist 15 (da ja ein Wert kleiner und nicht kleiner gleich und die 14 ja auch möglich sein sollte ...

Also hast Du eine Formel:
0*x+y <= r*x+y < x+y
mit den Grenzen:
2 <= r*x + y < 15

Damit hast Du bei den Grenzen doch folgende Gleichungen:
0*x + y = 2
x+y = 15

Also y = 2, x = 13

Das kannst Du einsetzen und du hast also r * 13 + 2 mit r der Zufallszahl von 0 bis 1.

==> (int) (Math.random() * 13 + 2)

Das einfach einmal um zu zeigen, wie wichtig paar Mathe-Kenntnisse sein können.

 

[KonradN]

Und was Deine Anforderungen angeht: Die musst Du erst einmal mit Worten formulieren. Was genau willst Du machen? Und was genau hast Du?

BlackJack ist da doch recht einfach (Einfach mal für 1 Spieler und Bank):

• Spieler zieht so lange er will
• Bank zieht so lange bis sie gewonnen oder verloren hat.
• Ergebnis wird ausgegeben.

Damit hast Du den ersten Code:

public void spieleBlackJack() {
    spielerZiehtSoLangeErWill();
    bankZiehtBisGewonnenOderVerloren();
    ergebnisAusgeben();
}

Jetzt musst Du aber natürlich sagen, was denn das "Spieler zieht so lange er will" bedeutet....
Das kann einfach sein:
So lange wie: Spieler will weitere Karte:
-- Spieler zieht eine Karte

Das kann man dann auch direkt in Code schreiben:

public void spielerZiehtSoLangeErWill() {
    while (spielerWillWeitereKarte()) {
        spielerZiehtKarte();
    }
}

Das kann man jetzt immer so weiter machen. Wann will der Spieler eine weitere Karte? Summe der Karten ist kleiner als ein Grenzwert oder Summe der Karten ist größer 21.
Hier wird dann wichtig: Wir brauchen also eine Liste an Karten. Oder zumindest von Kartenwerten. Da kann dann die ArrayList ins Spiel kommen. Und dann werden wir merken: Wir müssen die Summe der Kartenwerte berechnen können ...

Spieler zieht eine Karte kannst Du dann auch so aufbauen. Da wird dann halt eine zufällige Karte (Karte wäre dann bei uns erst einmal ein Kartenwert) ermittelt und dann der Liste der Spielerkarten zugeordnet.

Das dann auch noch einmal für die Bank und Du bist schon fast fertig.

Daher noch einmal ganz deutlich die Aussage: Beschreibe etwas erst einmal im Detail in Sprache. Schreib nicht direkt Code. Überlege Dir, wann was passieren soll. Du kannst da gerne Aufgaben einfach als ganzes Benennen und dieses dann im Anschluss angehen. Damit teilst Du ein Problem in Teilprobleme bis Du so kleine Teilprobleme hast, die alle einfach zu lösen sind.

 

[mihe7]

Aber kann ich das auch eingrenzen. Sprich das nur zahlen von 2-14 generiert werden?

Klasse java.util.Random an, die ein paar praktische Methoden enthält. Beispielsweise eine Methode nextInt, die ganzzahlige Zufallszahlen innerhalb definierten Grenzen liefert.

-> new Random().nextInt(2, 15)