[JAVA Projekt][Update] Ein Quartett programmieren

[Wincenty]

Hallo,
ich soll für meinen Prof an der Uni ein Projekt in Java machen und ich hab mich entschieden aus der Bauphysik den Wärmeverlauf einer Mauer zu berechnen entschieden.

Der Kern des Programm wird so ablaufen:

Eingabe der Anzahl der Mauersegmente
do {
Eingabe der Werte des Mauerstücks
Berechne den Wärmeverlauf
Speichere den Wärmeverlauf in temporärer Datenbank
} while bis Anzahl erreicht
lade alle Werte der temp. Datenbank aus
summiere alles (Datenbank wird danach nicht mehr verwendet)

Ausgabe

So sollte das Programm in Grunde arbeiten.

Meine Frage nun:

Wie erstelle ich in Java (in Eclipse) eine Datenbank (SQL bestenfalls)?
Eventuel könnt ihr mir noch erklären wie ich daraus ein Programm, also etwas kompiliere um nicht es über Eclipse zu starten, erstelle.
Der Professor hatte das zwar gesagt, habe aber es nicht verstanden weil er das so im Fluge gesagt hatte (wir hatten bereits 10min überzogen)

Ich wäre euch für die Hilfe sehr Dankbar

 

[bingo88]

AW: [JAVA Projekt] Wärmeverlauf einer Mauer - Temporäre Daten erstellen/entfernen

Du könntest z .B. mit JavaDB arbeiten, dass ist AFAIK in Java integriert bzw. wird mitinstalliert. Alternativ würde mir noch Hibernate einfallen. SQL (z. B. MySQL) kannst du auch machen, im Falle einer "richtigen" Datenbank muss dazu aber der entsprechende Server laufen und verfügbar sein.

Du kannst in Eclipse eine spezielle jar Datei erstellen lassen, die du (unter Windows) dann mit einem Doppelklick starten kannst (wie eine exe quasi). Du gehst dazu auf File -> Export -> Runnable Jar File.

 

[HanZ4000]

AW: [JAVA Projekt] Wärmeverlauf einer Mauer - Temporäre Daten erstellen/entfernen

Ist eine Datenbank unbedingt notwendig?
Reicht es nicht, wenn das Programm temporär in einem Array oder einer anderen Datenstruktur die Daten zwischenspeichert oder das man die Daten in ein File herrausschreibt und später wieder einliest?
Das würde die Sache wesentlich einfacher machen.

Ich weiss ja nicht, wie Dein Wissensstand in Java ist. Der folgende Link ist eine wunderbare Informationsquelle in Java.
Galileo Computing :: Java ist auch eine Insel - index

 

[Leandros]

AW: [JAVA Projekt] Wärmeverlauf einer Mauer - Temporäre Daten erstellen/entfernen

Also so wie du das beschreibst, ist eine Datenbank absolut overkill.

 

[Wincenty]

Der Prof war gütig und hatte mir ne Version einer Studentin die ein solches Programm geschrieben hat mir gegeben und ich habe versucht den Code zu verstehen und das war für mich schwer, das Programm lief aber auch nicht weil es noch Klassen benötigte die ich INet gezogen und platziert hab aber dennoch vieles fehlte.

Jetzt darf ich ein neues Projekt machen: eine Quartettspiel.

Ich habe erst mal damit begonnen eine Klasse AutoWerte zu erstellen die die Kartenwerte als Array beihnaltet geht das so wie im Code oder ist da was Banane?
Ich werde danach eine Klasse schreiben müssen welche die Karten dann zufällig mischt und verteilt.
Dabei hab ich gedacht mit Math.randon zu arbeiten, aber beim Googlen nach einer Idee (ich hab nach bereits existierenden Quartetts gesucht um zu schauen wie ich das machen könnte) aber nix gefunden aber dafür hab ich gefunden das es eine API/Funktion (weiß nicht mehr was es genau war) shuffle gibt, könnte mir jemand diese Funktion erklären und mir nen Ansatz geben, wie ich die Kartenreihenfolge speichern kann (ich vermutte mithilfe eines Arrays, nur sind Arrays nich so meine Stärke)

public class AutoWerte {

    public static void Audi_A4_DTM () {
        double [] array = new double [6];
        array[0]=290; //TopSpeed
        array[1]=4000; //Hubraum
        array[2]=4.3; // 0-100
        array[3]=8; //Zylinder
        array[4]=465; //PS
        array[5]=7300; //UproMin
    } ...

 

[Leandros]

Du kannst die Werte so Speichern, ist nicht optimal, aber für deinen Fall völlig ausreichend.

Zum mischen ist std::random_shuffle praktisch.

 

[DarkMo]

jetzt müsst ich erstmal wissen, was ein quartettspiel is ^^ und AutoWerte... steht hier auto für automatisch oder für automobil?

allgemeine idee: dein erstelltes array ist an sich doch schonmal nich verkehrt. vllt müsstest du hier ne textdatei anlegen, in der diese daten gespeichert sind. auslesen und in ner schleife diese werte auslesen, und das array füllen. bleibt die frage, wohin mit den arrays, bei jedem schleifendurchgang - ich würd glatt ne liste nehmen ^^ hab die tage erst mit ner arrayList gearbeitet, könnte ganz gut geeignet sein. weil damit könnte man auch ganz gut das zufällige ziehen realisieren *denk*

du erstellst also deine werte, packst diese in die liste und erstellst die nächsten werte (bis es keine neuen werte mehr gibt). dann würde ich für jeden spielgang eine kopie dieser liste erstellen (sonst müsstest du bei jedem rundenstart (wie gesagt, hier fehlt mir auch der durchblick, was quartettspiel is ^^ vllt gibts ja garkeine runden ) alles neu laden/erstellen. mit liste.get(index) *glaub* kannst du dann auf ein listenelement zugreifen -> einfach ein random von 0 bis arrayList.size()-1 ausführen und dir dieses element ausgeben lassen und dann aus der liste löschen (damit verhinderst du, dass du 2mal die selbe ziehen kannst). so kommt dann in zufälliger reihenfolge sone karte zum vorschein. zum nächsten rundenstart wird die arrayliste wieder mit den komplettdaten gefüttert.

alternativ könnte man auch 2 listen nehmen und aus der einen ein element "rauswürfeln" wie bisher, das ausgeben, es in die 2. liste speichern/anfügen und dann wieder aus der ersten löschen. am ende könnte man beide wieder mergen um ne komplettliste zu erhalten. so würde pro spieldurchgang auch noch die reihenfolge der karten in der liste variieren, zusätzlich zur zufälligen auslesung.

 

[Wincenty]

Ich hab jetzt was gefunden und auch verstanden wie das an sich Funktioniert, nur weiß ich nicht wie ich das modifzieren soll für meinen Fall
Das ist der Code von diesem Link

public State() {         /*this.pile = new int[6];         for (int i = 0; i < 6; i++) this.pile[i] = 6;         Math.random();                  int[] cardsP1 = new int[12];         for(int a =0; a<12; a++){             Math.random();         }*/                  //Erstellt den "pile" mit je 6 mal 0,1,2,3,4,5 allerdings noch geordnet                   ArrayList<Integer>pile = new ArrayList<Integer>();         int a = 0;         while(a<6){             for (int i = 0; i<6;i++){                 pile.add(a);             }             a++;                 }         // Mischt den "pile"                   java.util.Collections.shuffle(pile);                  //gibt beiden Spielern 12 Karten und entfernt diese gleichzeitig aus dem "Pile"          int[] kartenSpieler1 = new int[12];         for(int i = 0; i < 12; i++) {            kartenSpieler1[i] = pile.remove(i);}                  int[] kartenSpieler2 = new int[12];         for(int i = 0; i < 12; i++) {            kartenSpieler2[i] = pile.remove(i);}                       }

In meinem Fall wäre dann also pile mein Kartenstapel, meine Frage ist also wie lese ich meine Karten dort hinein, sollte ich die Arrays so modifizieren:

public static void Karte1 () {
        double [] array = new double [7];
        array[0]=290;
        array[1]=4000;
        array[2]=4.3;
        array[3]=8;
        array[4]=465;
        array[5]=7300;

    }

 

[Wincenty]

Ich hab jetzt was gefunden und auch verstanden wie das an sich Funktioniert, nur weiß ich nicht wie ich das modifzieren soll für meinen Fall
Das ist der Code von diesem Link

public State() {         /*this.pile = new int[6];         for (int i = 0; i < 6; i++) this.pile[i] = 6;         Math.random();                  int[] cardsP1 = new int[12];         for(int a =0; a<12; a++){             Math.random();         }*/                  //Erstellt den "pile" mit je 6 mal 0,1,2,3,4,5 allerdings noch geordnet                   ArrayList<Integer>pile = new ArrayList<Integer>();         int a = 0;         while(a<6){             for (int i = 0; i<6;i++){                 pile.add(a);             }             a++;                 }         // Mischt den "pile"                   java.util.Collections.shuffle(pile);                  //gibt beiden Spielern 12 Karten und entfernt diese gleichzeitig aus dem "Pile"          int[] kartenSpieler1 = new int[12];         for(int i = 0; i < 12; i++) {            kartenSpieler1[i] = pile.remove(i);}                  int[] kartenSpieler2 = new int[12];         for(int i = 0; i < 12; i++) {            kartenSpieler2[i] = pile.remove(i);}                       }

In meinem Fall wäre dann also pile mein Kartenstapel, meine Frage ist also wie lese ich meine Karten dort hinein, sollte ich die Arrays so modifizieren:

public static void Karte1 () {
        double [] array = new double [7];
        array[0]=290;
        array[1]=4000;
        array[2]=4.3;
        array[3]=8;
        array[4]=465;
        array[5]=7300;
        array[6]= "Audi A4 DTM";  //(ist mir klar das ich das hier falsch hab, da ich einen String für den Namen der Karte benötige und nicht in eine Double setzten kann)
    }

Damit ich einfacher die Karten den in pile einsetzten könnte. Oder bin ich auf dem Holzweg?

 

[DarkMo]

du kannst statt eines arrays doch auch ein strucks oder ne klasse nutzen. da kannste dann auch floats und strings mischen. falls du dann mit soner liste arbeitest, kannst du ja dann objekte/instanzen davon adden und gut ist.

zudem ist der erste code völlig versaubeutelt

public State() {
    /*this.pile = new int[6];
    for (int i = 0; i < 6; i++) this.pile[i] = 6;
         Math.random();
     int[] cardsP1 = new int[12];
     for(int a =0; a<12; a++) {
         Math.random()
    }*/

    //Erstellt den "pile" mit je 6 mal 0,1,2,3,4,5 allerdings noch geordnet
     ArrayList<Integer> pile = new ArrayList<Integer>();
     int a = 0;
     while(a<6) {
         for (int i = 0; i<6;i++) {
             pile.add(a);
         }
         a++;
    }

    // Mischt den "pile"
    java.util.Collections.shuffle(pile);

    //gibt beiden Spielern 12 Karten und entfernt diese gleichzeitig aus dem "Pile"
     int[] kartenSpieler1 = new int[12];
     for(int i = 0; i < 12; i++) {
         kartenSpieler1[i] = pile.remove(i);
     }
     int[] kartenSpieler2 = new int[12];
     for(int i = 0; i < 12; i++) {
         kartenSpieler2[i] = pile.remove(i);
     }
}

der arbeitet auch mit ner arraylist. hier halt mit integer werten (ArrayList<Integer>). machst du hier ne klasse Karte meinetwegen mit den ganzen klassen-variablen (int hubraum, float a (beschl. 0-100), int zylinder, int maxV...), hast du ersten viel schönere variablen namen anstelle der indizes des arrays und kannst eben bverschiedene variablen typen mischen. und natürlich kannst du dann ArrayList<Karte> machen um mit pile.add(karten-objekt); ne karte hinzuzufügen.

 

[Leandros]

Würde dir eine ArrayList<Struct> oder ArrayList<HashMap<String, String>> empfehlen.
Die ints (bzw zahlen allgemein) kannst du als String speichern, ist besser. Kann man ja nach Lust und Laune hin und her umwandeln.

 

[Wincenty]

Ich habe das jetzt so:
eine ArrayList names Karten wo die Namen der Fahrzeuge aufgelistet ist und danach jeder fahrzeugname als eigene Liste mit den Werten das ist dann in etwa so:

import java.util.ArrayList;
import java.util.List;

public class AutoWerte {

    public static void main(String [] args) {
        
        List<String> Karten = new ArrayList<String>();
        Karten.add("Audi_A4_DTM");
        Karten.add("Chrysler_Viper_GTSR");
        Karten.add("Citroen_Xsara_WRC");
....

        List<String> Audi_A4_DTM = new ArrayList<String>();
        Audi_A4_DTM.add("290");
        Audi_A4_DTM.add("4000");
        Audi_A4_DTM.add("4.3");
        Audi_A4_DTM.add("8");
        Audi_A4_DTM.add("465");
        Audi_A4_DTM.add("7300");
...

Das ist bisher gut so oder?

 

[DarkMo]

wieso so umständlich?

public class Karte {
    public string Name;
    public int TopSpeed;
    public int Hubraum;
    public float TimeTo100;
    public int Zylinder;
    public int PS;
    public int RpM;

    Karte(string Name, int TopSpeed, int Hubraum, float TimeTo100, int Zylinder, int PS, int RPM) {
        this.Name = Name;
        this.TopSpeed = TopSpeed;
        this.Hubraum = Hubraum;
        this.TimeTo100 = TimeTo100;
        this.Zylinder = Zylinder;
        this.PS = PS;
        this.RpM = RpM;
    }
}

kannst die variablen natürlich auch private machen, nur hier der einfachheit halber mal fix so gemacht.

import java.util.ArrayList;
import java.util.List;

public class AutoWerte {
    public static void main(String [] args) {
        List<Karte> Karten = new ArrayList<Karte>(); // hier vom typ der Karte-Klasse
        Karten.add(new Karte("Audi_A4_DTM", 290, 4000, 4.3, 8, 465, 7300));
        Karten.add(new Karte("Chrysler_Viper_GTSR", ...));
        Karten.add(new Karte("Citroen_Xsara_WRC", ...));
    }
}

später kannste dann über

Karten.get(0).Name;

als bsp den namen von ner karte ausgeben lassen. oder wenn di private sind halt .getName(); oder so.

 

[Leandros]

Public vars? Ganz böse. Immer getter und setter nutzen.
Constructor gehören allerdings public.

Hätte es genau so wie DarkMo gemacht, nutze es ähnlich auch öfters.

Edit: Falls du keine extra Klasse erstellen möchtest, kannst du auch ArrayList<Map<String, String>> nutzen. Der 1. Wert ist dann der key, der zweite value.

 

[DarkMo]

ja wie gesagt, habs nur der einfachheit halber public gemacht. um daraufhinzuweisen, hab ichs erwähnt ^^ aber gut, beim konstruktor kam mir auch was komisch vor, das public fehlt ^^

 

[Wincenty]

jetzt bilck ich nicht ganz durch:

also wie es jetzt ist, wäre ok aber nicht "schön"

schöner ware die Variante von DarkMo, nur hab ich nicht ganz verstenden, ist der erste Code oder der 2. zu favorisieren?

Ich hätte es lieber als eigene Klasse, da ich es so als übersichtlicher empfinden würde wenn fertig ist.

 

[Crymes]

Dss isz ein zusammenhängender Code und eine Kartenklasse ist extrem sinnvoll.
Im 2. Abschnitt werden beliebig viele Karzen gespeichert, so kannst du alle Spielkarten verwalten.
Ich würde das nicht in eine einzige Klasse packen.

 

[Wincenty]

bei diesem Code markiert Eclipse das als Fehler:

import java.util.ArrayList;
import java.util.List;

public class AutoKarten {
    public static void main(String [] args) {
        List<Karten> Karten = new ArrayList<Karten>(); // hier vom typ der Karte-Klasse
        Karten.add([COLOR=red]new Karten("Audi_A4_DTM", 290, 4000, 4.3, 8, 465, 7300));
        Karten.add(new Karten("Chrysler_Viper_GTSR", ...));
        Karten.add(new Karten("Citroen_Xsara_WRC", ...));
    }
}

mit dieser Begründung: The constructor Karten(String, int, int, double, int, int, int) is undefined

Wobei die Klasse

public class Karten {
    public String Name;
    public int TopSpeed;
    public int Hubraum;
    public float TimeTo100;
    public int Zylinder;
    public int PS;
    public int RpM;

    public Karten(String Name, int TopSpeed, int Hubraum, float TimeTo100, int Zylinder, int PS, int RPM, int RpM) {
        this.Name = Name;
        this.TopSpeed = TopSpeed;
        this.Hubraum = Hubraum;
        this.TimeTo100 = TimeTo100;
        this.Zylinder = Zylinder;
        this.PS = PS;
        this.RpM = RpM;
    }
}

vorhanden ist, wenn ich versuche den Konstruktor zu ändern dann erstellt er mir in der Klasse Karten das:

public Karten(String string, int i, int j, double d, int k, int l, int m) {
        // TODO Auto-generated constructor stub
    }

Ich hab jetzt die Klasse Karten nun so abgeändert:

public class Karten {
    public String Name;
    public int TopSpeed;
    public int Hubraum;
    public double TimeTo100;
    public int Zylinder;
    public int PS;
    public int RpM;

    public Karten(String string, int i, int j, double d, int k, int l, int m) {
        // TODO Auto-generated constructor stub
        this.Name = string;
        this.TopSpeed = i;
        this.Hubraum = j;
        this.TimeTo100 = d;
        this.Zylinder = k;
        this.PS = l;
        this.RpM = m;
    }
}

Kann man das jetzt so lassen?

Kennt jemand ein Tutorial Video für die Funktion shuffle? oder mir es erklären? Weil YT spuckt mir nur Videos raus welche Kartenmischertricks in RL zeigen.

[EDIT]

Ich hab jetzt mal ne Klasse Stapel welche die Karten beinhalten soll wenn diese gemischt sind

import java.util.List;

public class Stapel {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) {

    AutoKarten Stapel = new AutoKarten();
    java.util.Collections.shuffle((List<AutoKarten>) Stapel);

    }
}

Ich glaub das ist Banane, sicher bin ich mir nicht.

@DarkMo, ich hab grad erst gesehen deine Frage: ich meine es soll ein Automobil-Kartenspiel werden mit 32 Karten. Jeder Spieler bekommt 16 Karten (nachdem gemischt), einer fängt an, er wällt einen Wert aus, wenn sein Wert besser ist als die vom anderen bekommt er die Karte des anderen und seine muss er dann hinten in seinen Stapel mitsamt der anderen gewonnen einreihen. Das Spiel geht solange bis einer keine Karten mehr hat.

D.h. ich hab in der Klasse AutoKarten die Karten und deren Werte definiert. Die Liste soll in Stapel geladen werden. Dort wird die Reihenfolge durcheinander gebracht, also gemischt. Danach soll der gemischte Stapel in 2 geteilt werden. In RL werden die Karten abwechselnd verteilt, hier muss es nicht sein, wäre aber toll. Also werden die Karten aus Stapel entfernt und in StapelSpielerLinks und StapelSpielerRechts geaddet.
Das Programm wird beim Starten zuerst fragen wie SpielerLinks und SpielerRechts heißen. Dann wird zufällig mittels Math.random() einer der Beiden beginnen, das Fenster ist in 2 geteilt, zu sehen werden die Karten sein. Wenn SpielerRechts dran ist dann sieht er seine Karte mit den Werten als ein Bild und daneben 6 Ausfahlfelder oder Buttons wo er seine Wahl trifft, währendessen sieht der andere Spieler nur die Kartenrückseite (ebenfalls ein Bild) und ohne Auswahloption. Wenn der Spieler seine Wahl getroffen hat, wird die Karte gedreht (keine Animation) und das Auswahlfeld soll in Rot bei Niederlage oder grün bei Sieg aufblinken. Und wenn ein Spieler verliert soll ein kleines Fenster aufspringen wo drin steht wer gewonnen hat und drunter als Auswahlmöglichkeit: Neue Spieler - erneut Spielen - Beenden.

 

[DarkMo]

das prob beim konstruktor is einfach, dass die parameterliste ned stimmt. dass er da nen double statt nen float sieht is noch das geringere. entweder machste aus dem float-typ in der klasse (und damit auch den parameter) zu double, oder du übergibst 4.3f statt 4.3 oder du übergibst (float)4.3 - also halt casten. das größere problem (das was ihn wirklich auf die compiler-palme bringt) ist die falsche parameter anzahl. wenn dus von mir kopiert hast, is da sicher nen fehler unterlaufen bei mir (ist halt nicht meine logik ^^). kontrollier einfach, welche werte du brauchst und speicher die. beim aufruf musst du dann natürlich genügend richtige parameter angeben (bei der version fehlte nen intwert am ende - oder war zuviel). einfach nochmal kontrollieren.

 

[Wincenty]

So sieht es jetzt aus:
Klasser Karten:

public class Karten {
    public String Name;
    public int TopSpeed;
    public int Hubraum;
    public double TimeTo100;
    public int Zylinder;
    public int PS;
    public int RpM;

    public Karten(String name, int topspeed, int hubraum, double beschleunigung, int zylinder, int ps, int rpm) {
        // TODO Auto-generated constructor stub
        this.Name = name;
        this.TopSpeed = topspeed;
        this.Hubraum = hubraum;
        this.TimeTo100 = beschleunigung;
        this.Zylinder = zylinder;
        this.PS = ps;
        this.RpM = rpm;
    }
}

Und die Klasse AutoKarten:

import java.util.ArrayList;
import java.util.List;

public class AutoKarten {
    public static void main(String [] args) {
        List<Karten> Karten = new ArrayList<Karten>(); // hier vom typ der Karten-Klasse
        Karten.add(new Karten("Audi_A4_DTM", 290, 4000, 4.3, 8, 465, 7300));
        Karten.add(new Karten("Chrysler_Viper_GTSR", 315, 7986, 3.7, 10, 600, 7000));
        Karten.add(new Karten("Citroen_Xsara_WRC", 270, 1998, 4.7, 4, 305, 7300));
        Karten.add(new Karten("VW_Polo_Super1600",205,1598,5.8,4,215,8750));
           Karten.add(new Karten("Opel_Vectra_GTS",285,3998,4.4,8,465,6800));
        Karten.add(new Karten("Bentley_EXP_Speed8",335,3994,3.8,8,620,7900));
        Karten.add(new Karten("Skoda_Fabia_WRC",275,1999,4.6,4,295,6900));
        Karten.add(new Karten("BMW_320i_WTCC",250,1998,4.4,4,275,8800));
        Karten.add(new Karten("Nissan_350Z_JGTC",330,2987,4.1,6,465,5600));
        Karten.add(new Karten("Maserati_MC12",335,5998,3.8,12,630,7700));
        Karten.add(new Karten("Mitsubishi_Lancer_WRC",280,1999,4.4,4,300,7700));
        Karten.add(new Karten("Lister_Storm_GT",325,6996,3.7,12,630,8400));
        Karten.add(new Karten("Mercedez_C_AMG",295,4000,4.1,8,465,7500));
           Karten.add(new Karten("Porsche_911_Carrera_RS",280,3600,4.8,6,280,6800));
           Karten.add(new Karten("Subaru_Impreza_WRC",285,1998,4.8,4,310,6900));
           Karten.add(new Karten("Cadillac_CTSV",265,6026,4.9,8,500,7800));
           Karten.add(new Karten("Pescarolo_Judd_LMP1",385,4997,3.0,10,630,8100));
        Karten.add(new Karten("TVR_Tuscan_400R",330,3996,3.9,6,446,7600));
        Karten.add(new Karten("Volvo_S60",280,2400,4.6,5,285,6500));
        Karten.add(new Karten("Chevrolet_Lacetti_WTCC",254,1998,4.5,4,280,8500));
        Karten.add(new Karten("Vauxhall_Astra",298,3998,3.9,8,335,6900));
        Karten.add(new Karten("AlflaRomeo_147_GTACup",230,1970,5.6,4,220,7000));
        Karten.add(new Karten("Morgan_Aero_GT",330,4398,4.1,8,500,6300));
        Karten.add(new Karten("Suzuki_Ignis",225,1598,6.0,4,215,8750));
        Karten.add(new Karten("Porsche_996_GT3_RSR",295,3598,3.1,6,451,8250));
        Karten.add(new Karten("Audi_R8",330,3600,3.3,8,593,8050));
        Karten.add(new Karten("Porsche_911_GT1",355,3200,3.5,6,600,7200));
        Karten.add(new Karten("Heiko_HS4_ODIN",275,2521,5.5,5,354,6000));
        Karten.add(new Karten("Peugeot_307_WRC",290,1998,4.3,4,298,6500));
        Karten.add(new Karten("Seat_Leon_Supercopa",235,1797,4.8,4,254,6300));
        Karten.add(new Karten("Ford_Focus_WRC",205,1998,3.9,4,300,6000));
        Karten.add(new Karten("Ferrari_F40",325,4706,3.7,12,521,8700));
    }
}

Jetzt habe ich ein Klasse Stapel in welcher die ArrayListe reingeladen werden soll und dann die Karten gemishct, also die Reihenfolge geändert werden.
Danach sollen abwechselnd eine Karte aus Stapel in StapelSL und StapelSR hinzugefügt werden, bis der der Stapel leer ist.

Ich habe versucht die Karten in den Stapel zu laden und danach zu mischen und es sieht so aus:

import java.util.List;

public class Stapel {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) {

    AutoKarten Stapel = new AutoKarten();
    java.util.Collections.shuffle((List<AutoKarten>) Stapel);

    }
}

Kann es sein dass ich hier Mist gebaut hab? ich hab bisher noch nicht mit Arraylisten gearbeitet und weiß eigentlich nicht wirrklich weiter, weil ich nicht weiß ob das so korrekt ist.