Integer aus Textdatei auslesen

Einen wunderschönen Guten Tag,

ich muss als Unterrichtsprojekt innerhalb eines Jahres ein kleines Spiel meiner Wahl in Java entwerfen. Java hatten wir in der Schule jetzt fatalerweise nur 3 Monate kurz angeschnitten, weshalb ich manchmal etwas amateurhaft mal nachfragen muss, was ich wo falsch gemacht habe. Es geht aktuell sehr gut voran!
Eine Frage hätte ich da. Ich möchte gerne meinen Spielstand abspeichern, wenn ich das Spiel schließe und beim erneuten Öffnen den Spielstand wieder abrufen.

Hierzu habe ich in mein Javaverzeichnis die Datei “spielstand.txt” integriert. Das Spiel bezieht sich auf zahlreiche Integer, die im Hintergrund alle möglichen Algorithmen des Spiels steuern.
Meine Textdatei sieht zum Beispiel so aus:

gastkarten:100
laenderkarten:24
spieleramzug:2
punktespieler1:37
punktespieler2:45

Durch den Doppelpunkt getrennt sind einerseits die einzuspeichernde Variable und auf der rechten Seite stehts der Wert, den ich einfügen möchte.

Was ich erreichen möchte ist nun, dass das Programm beim aufrufen sofort überprüft, ob spielstand.txt vorhanden ist und dann die Zeilen absucht und in die Variablen abspeichert.
Also hab ich beispielsweise die Variable punktespieler1 und er soll die Zeile suchen und die Zahl die hinter dem Doppelpunkt steht brav in den gleichnamigen Integer reinschreiben.

Ich hab viel gegooglet, aber ehrlich gesagt bisher nicht viel verstanden, was dort alles erklärt wird. Kann mir da jemand kurz weiterhelfen?
Mein bisheriger Programmcode ist dieser:

import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.util.*;

public class CafeRoot extends JFrame {
  // Anfang Attribute
  private JLabel jLabelRestkartenTisch = new JLabel();
  private JLabel jLabelRestkartenGast = new JLabel();
  private JLabel jLabelRestbarplaetze = new JLabel();
  private JLabel jLabelHandkartenSpieler1 = new JLabel();
  private JLabel jLabelHandkartenSpieler2 = new JLabel();
  private JLabel jLabelPunkteSpieler1 = new JLabel();
  private JLabel jLabelPunkteSpieler2 = new JLabel();
  private JLabel jLabelSpieler = new JLabel();
  private JList jListGastkarten = new JList();
  //private DefaultListModel jListGastkartenModel = new DefaultListModel();
  //private JScrollPane jListGastkartenScrollPane = new JScrollPane(jListGastkarten);
  // Ende Attribute
  
  public CafeRoot(String title) { 
    // Frame-Initialisierung
    super(title);
    setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    
    int frameWidth = 468; 
    int frameHeight = 434;
    setSize(frameWidth, frameHeight);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    int x = (d.width - getSize().width) / 2;
    int y = (d.height - getSize().height) / 2;
    setLocation(x, y);
    setResizable(false);
    Container cp = getContentPane();
    setTitle("Café International");
    setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
    setLocationRelativeTo(null);
    cp.setLayout(null);
    
    // Anfang Komponenten
    int restkartentisch = 24;
    jLabelRestkartenTisch.setBounds(25, 10, 100, 30);
    jLabelRestkartenTisch.setText("Resttische: "+restkartentisch);
    cp.add(jLabelRestkartenTisch);
    //=============================
    int restkartengast = 0; //werden noch gemischt
    jLabelRestkartenGast.setBounds(25, 35, 100, 30);
    jLabelRestkartenGast.setText("Restgäste: "+restkartengast);
    cp.add(jLabelRestkartenGast);
    //=============================
    int restbarplaetze = 21;
    jLabelRestbarplaetze.setBounds(25, 60, 120, 30);
    jLabelRestbarplaetze.setText("Barplätze übrig: "+restbarplaetze);
    cp.add(jLabelRestbarplaetze);
    //=============================
    int handkartenspieler1 = 0;//werden noch ausgeteilt
    jLabelHandkartenSpieler1.setBounds(25, 85, 140, 30);
    jLabelHandkartenSpieler1.setText("Karten Spieler 1: "+handkartenspieler1);
    cp.add(jLabelHandkartenSpieler1);
    //=============================
    int handkartenspieler2 = 0;
    jLabelHandkartenSpieler2.setBounds(25, 110, 140, 30);
    jLabelHandkartenSpieler2.setText("Karten Spieler 2: "+handkartenspieler2);
    cp.add(jLabelHandkartenSpieler2);
    //=============================
    int punktespieler1 = 0;
    jLabelPunkteSpieler1.setBounds(25, 135, 140, 30);
    jLabelPunkteSpieler1.setText("Pkt. Spieler 1: "+punktespieler1);
    cp.add(jLabelPunkteSpieler1);
    //=============================
    int punktespieler2 = 0;
    jLabelPunkteSpieler2.setBounds(25, 160, 140, 30);
    jLabelPunkteSpieler2.setText("Pkt. Spieler 2: "+punktespieler2);
    cp.add(jLabelPunkteSpieler2);
    //=============================
    int spieler = 1;
    jLabelSpieler.setBounds(25, 185, 140, 30);
    jLabelSpieler.setText("Am Zug: Spieler "+spieler);
    cp.add(jLabelSpieler);
    //=============================
    DefaultListModel jListGastkartenModel = new DefaultListModel();
    JList jList = new JList(jListGastkartenModel);
    JScrollPane jListGastkartenScrollPane = new JScrollPane(jListGastkarten);
    jListGastkarten.setModel(jListGastkartenModel);
    jListGastkartenScrollPane.setBounds(25, 210, 297, 121);
    cp.add(jListGastkartenScrollPane);
    jListGastkarten.setVisible(true);
    // Ende Komponenten
    
    setVisible(true);
    addWindowListener(new MyWindowListener(this));
    //=============================
    String[] laender = {"Deutscher", "Franzake", "Brite", "Ami", "Türke", "Inder", "Chinese", "Russe", "Spanier", "Kuba", "Afrikaner", "Italiener", "Joker"};
    String[] geschlecht = {"m", "w"};
    String[][] a = new String [2][(laender.length+1)*(geschlecht.length+1)*(4)];
    
    for(int k=0;k<4;k++)
    {
      for(int i=0; i<13; i++)
      { 
        for(int j=0; j<=1; j++)
        {
          a[0][(i+1)*(k+1)*(j+1)]=laender**;
          a[1][(i+1)*(k+1)*(j+1)]=geschlecht[j];
          //jListGastkarten.addElement(**[j]);
          jListGastkartenModel.addElement(laender**+" ; "+geschlecht[j]);
          restkartengast = restkartengast + 1;
          
        }
      }
    }
    jLabelRestkartenGast.setText("Restgäste: "+restkartengast);
    //Collections.shuffle(a[0]);
  }
  
  // Anfang Methoden
  
  // Ende Methoden
  
  public static void main(String[] args) {
    new CafeRoot("CafeRoot");
  } // end of main 
  public class MyWindowListener implements WindowListener {
    
    private CafeRoot cRoot;
    
    public MyWindowListener(CafeRoot cRoot) {
      this.cRoot = cRoot;
    }
    
    @Override
    public void windowActivated(WindowEvent arg0) { }
    
    @Override
    public void windowClosed(WindowEvent arg0) {
      cRoot.setVisible(false);  
    }
    
    @Override
    public void windowClosing(WindowEvent evt)
    {
      final JFrame Beenden = new JFrame("Ein Frame zum Schließen");
      Beenden.setTitle("Programm beenden");
      Object[] options = {"Ja", "Nein"};
      /*int beenden = JOptionPane.showConfirmDialog(null, 
      "Wollen Sie das Programm wirklich beenden?
Ihr Spielstand wird verloren gehen!",
      "Café International Beenden?",
      JOptionPane.WARNING_MESSAGE,
      JOptionPane.YES_NO_OPTION);*/
      int beenden = JOptionPane.showOptionDialog(null,
      "Wollen Sie das Programm wirklich beenden?
Ihr Spielstand wird verloren gehen!",
      "Café International Beenden?",
      JOptionPane.DEFAULT_OPTION, 
      JOptionPane.QUESTION_MESSAGE, 
      null, options, options[0]);
      if(beenden == 0)
      {
        //cRoot.dispose();
        System.exit(0);
      }
    }
    
    @Override
    public void windowDeactivated(WindowEvent arg0) { }
    @Override
    public void windowDeiconified(WindowEvent arg0) { }
    @Override
    public void windowIconified(WindowEvent arg0) { }
    @Override
    public void windowOpened(WindowEvent arg0) { }
    
    
  }
} // end of class CafeRoot

Ich hab bereits gelernt, dass man für meine Zwecke diesen Importbefehl oben mit einbauen muss:
import java.io.*;

Aber bisher waren mit die Quellen zu kompliziert. Kann mir jemand erklären, wie ich das machen soll und wo der dazu passende Code in meiner Datei reingehört?

Quellen waren bisher für mich:
Java, Werte aus .txt Datei nacheinander einlesen - ComputerBase Forum
Zahlen aus Textdatei lesen und in Konsole ausgeben
Integer aus Textdatei auslesen und in Variable speichern

Vielen Lieben Dank!
Gruß
Lukas

PS: Wenn jemand Zeit hat, wäre ich begeistert, wenn man dahinter kurz //kommentieren könnte, was wozu da ist. Ich möchte hier nicht einfach die “Copycat” spielen, die sich die Codes geben lässt aber keine Ahnung hat, wozu der da ist, dann präge ich mir das ja nie ein.

Um eine Textdatei einzulesen brauchst du bspw. einen [japi]InputStreamReader[/japi], der aus einem InputStream liest. Die Effizienz des Readers kann erhöht werden, wenn er gepuffert wird. Diese Funktionalität wird durch die Klasse [japi]BufferedReader[/japi] bereit gestellt.
Der Instanz des Readers wird also ein konketer InputStream zur Datenquelle übergeben. In deinem Fall ist die Datenquelle eine Datei, also brauchst du einen [japi]FileInputStream[/japi], der aus Dateien lesen kann. Da deine Datei nur aus Zeichenketten (Strings) besteht, kannst du den auf reine Textdateien spezialisierten [japi]FileReader[/japi], als Subklasse von FileInputStream, verwenden.

BufferedReader reader = new BufferedReader(new FileReader(...));```

Die Datei kann dann zeilenweise ausgelesen werden:
```//auslesen
String line = null;
while((line = reader.readLine) != null) {
   String[] keyValue = line.split(":");
   if(line.startsWith("punktespieler1")) {
      jLabelPunkteSpieler1.setText("Pkt. Spieler 1: "+keyValue[1]);
   }
   else if {
      ...
   }
}
reader.close();

Wenn du den Wert als int verarbeiten möchtest, muss er (keyValue[1]) noch entsprechend umgewandelt werden.
Und da dabei auch eine Menge schief gehen kann, muss das Ganze noch in einen try-catch-Block gepackt werden.

Einen wunderschönen Guten Tag und Vielen Dank für die schnelle Antwort.
Das Programm funktioniert wunderbar so. Ich musste nur ein paar Klammerfehler im Quelltext korrigieren. :wink:
Ich hab es jetzt folgendermaßen drin:

import java.awt.event.*;

import javax.swing.*;
import javax.swing.event.*;

import java.util.*;
import java.io.*;

public class CafeRoot extends JFrame {
  // Anfang Attribute
  private JLabel jLabelRestkartenTisch = new JLabel();
  private JLabel jLabelRestkartenGast = new JLabel();
  private JLabel jLabelRestbarplaetze = new JLabel();
  private JLabel jLabelHandkartenSpieler1 = new JLabel();
  private JLabel jLabelHandkartenSpieler2 = new JLabel();
  private JLabel jLabelPunkteSpieler1 = new JLabel();
  private JLabel jLabelPunkteSpieler2 = new JLabel();
  private JLabel jLabelSpieler = new JLabel();
  private JList jListGastkarten = new JList();
  //private DefaultListModel jListGastkartenModel = new DefaultListModel();
  //private JScrollPane jListGastkartenScrollPane = new JScrollPane(jListGastkarten);
  // Ende Attribute
  
  public CafeRoot(String title) throws IOException {
    // Frame-Initialisierung
    super(title);
    setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    BufferedReader reader = new BufferedReader(new FileReader("spielstand.txt"));
    int frameWidth = 468; 
    int frameHeight = 434;
    setSize(frameWidth, frameHeight);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    int x = (d.width - getSize().width) / 2;
    int y = (d.height - getSize().height) / 2;
    setLocation(x, y);
    setResizable(false);
    Container cp = getContentPane();
    setTitle("Café International");
    setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
    setLocationRelativeTo(null);
    cp.setLayout(null);
    
    // Anfang Komponenten
    int restkartentisch = 24;
    jLabelRestkartenTisch.setBounds(25, 10, 100, 30);
    jLabelRestkartenTisch.setText("Resttische: "+restkartentisch);
    cp.add(jLabelRestkartenTisch);
    //=============================
    int restkartengast = 0; //werden noch gemischt
    jLabelRestkartenGast.setBounds(25, 35, 100, 30);
    jLabelRestkartenGast.setText("Restgäste: "+restkartengast);
    cp.add(jLabelRestkartenGast);
    //=============================
    int restbarplaetze = 21;
    jLabelRestbarplaetze.setBounds(25, 60, 120, 30);
    jLabelRestbarplaetze.setText("Barplätze übrig: "+restbarplaetze);
    cp.add(jLabelRestbarplaetze);
    //=============================
    int handkartenspieler1 = 0;//werden noch ausgeteilt
    jLabelHandkartenSpieler1.setBounds(25, 85, 140, 30);
    jLabelHandkartenSpieler1.setText("Karten Spieler 1: "+handkartenspieler1);
    cp.add(jLabelHandkartenSpieler1);
    //=============================
    int handkartenspieler2 = 0;
    jLabelHandkartenSpieler2.setBounds(25, 110, 140, 30);
    jLabelHandkartenSpieler2.setText("Karten Spieler 2: "+handkartenspieler2);
    cp.add(jLabelHandkartenSpieler2);
    //=============================
    int punktespieler1 = 0;
    jLabelPunkteSpieler1.setBounds(25, 135, 140, 30);
    jLabelPunkteSpieler1.setText("Pkt. Spieler 1: "+punktespieler1);
    cp.add(jLabelPunkteSpieler1);
    //=============================
    int punktespieler2 = 0;
    jLabelPunkteSpieler2.setBounds(25, 160, 140, 30);
    jLabelPunkteSpieler2.setText("Pkt. Spieler 2: "+punktespieler2);
    cp.add(jLabelPunkteSpieler2);
    //=============================
    int spieler = 1;
    jLabelSpieler.setBounds(25, 185, 140, 30);
    jLabelSpieler.setText("Am Zug: Spieler "+spieler);
    cp.add(jLabelSpieler);
    String line = null;
    while((line = reader.readLine()) != null) {
       String[] keyValue = line.split(":");
       if(line.startsWith("punktespieler1")) {
          jLabelPunkteSpieler1.setText("Pkt. Spieler 1: "+keyValue[1]);
       }
       /*else {

       }*/
    }
    reader.close();
    //=============================
    DefaultListModel jListGastkartenModel = new DefaultListModel();
    JList jList = new JList(jListGastkartenModel);
    JScrollPane jListGastkartenScrollPane = new JScrollPane(jListGastkarten);
    jListGastkarten.setModel(jListGastkartenModel);
    jListGastkartenScrollPane.setBounds(25, 210, 297, 121);
    cp.add(jListGastkartenScrollPane);
    jListGastkarten.setVisible(true);
    // Ende Komponenten
    
    setVisible(true);
    addWindowListener(new MyWindowListener(this));
    //=============================
    String[] laender = {"Deutscher", "Franzake", "Brite", "Ami", "Türke", "Inder", "Chinese", "Russe", "Spanier", "Kuba", "Afrikaner", "Italiener", "Joker"};
    String[] geschlecht = {"m", "w"};
    String[][] a = new String [2][(laender.length+1)*(geschlecht.length+1)*(4)];
    
    for(int k=0;k<4;k++)
    {
      for(int i=0; i<13; i++)
      { 
        for(int j=0; j<=1; j++)
        {
          a[0][(i+1)*(k+1)*(j+1)]=laender**;
          a[1][(i+1)*(k+1)*(j+1)]=geschlecht[j];
          //jListGastkarten.addElement(**[j]);
          jListGastkartenModel.addElement(laender**+" ; "+geschlecht[j]);
          restkartengast = restkartengast + 1;
          
        }
      }
    }
    jLabelRestkartenGast.setText("Restgäste: "+restkartengast);
    //Collections.shuffle(a[0]);
  }
  
  // Anfang Methoden
  
  // Ende Methoden
  
  public static void main(String[] args) throws IOException {
    new CafeRoot("CafeRoot");
  } // end of main 
  public class MyWindowListener implements WindowListener {
    
    private CafeRoot cRoot;
    
    public MyWindowListener(CafeRoot cRoot) {
      this.cRoot = cRoot;
    }
    
    @Override
    public void windowActivated(WindowEvent arg0) { }
    
    @Override
    public void windowClosed(WindowEvent arg0) {
      cRoot.setVisible(false);  
    }
    
    @Override
    public void windowClosing(WindowEvent evt)
    {
      final JFrame Beenden = new JFrame("Ein Frame zum Schließen");
      Beenden.setTitle("Programm beenden");
      Object[] options = {"Ja", "Nein"};
      /*int beenden = JOptionPane.showConfirmDialog(null, 
      "Wollen Sie das Programm wirklich beenden?
Ihr Spielstand wird verloren gehen!",
      "Café International Beenden?",
      JOptionPane.WARNING_MESSAGE,
      JOptionPane.YES_NO_OPTION);*/
      int beenden = JOptionPane.showOptionDialog(null,
      "Wollen Sie das Programm wirklich beenden?
Ihr Spielstand wird verloren gehen!",
      "Café International Beenden?",
      JOptionPane.DEFAULT_OPTION, 
      JOptionPane.QUESTION_MESSAGE, 
      null, options, options[0]);
      if(beenden == 0)
      {
        //cRoot.dispose();
        System.exit(0);
      }
    }
    
    @Override
    public void windowDeactivated(WindowEvent arg0) { }
    @Override
    public void windowDeiconified(WindowEvent arg0) { }
    @Override
    public void windowIconified(WindowEvent arg0) { }
    @Override
    public void windowOpened(WindowEvent arg0) { }
    
    
  }
} // end of class CafeRoot

Das Else hab ich kurzfristig auskommentiert, damit ich sehen kann, ob das ganze läuft. Schein gut zu laufen. Mit Try und catch hast Du Recht/Link, da muss ich noch was einbauen. Beispielsweise wäre es essentiell vorher zu wissen, ob die Datei spielstand.txt überhaupt existiert. Das mache ich alles noch, vielen Dank. Ich melde mich, wenn ich dahingehend vorangeschritten bin.

Zwei (eine dritte Anmerkung) kleine Fragen hab ich noch:

  1. Ist da irgendwas ungünstig gelöst oder Quelltextmäßig verwerflich, wie ich das da jetzt eingefügt habe? Funktioniert zwar, aber ich lasse mich immer eines besseren belehren, wenn ich das seltsam gelöst habe oder es noch viel einfacher funktioniert.
    ====
  2. Nun würde ich gerne noch die andere Richtung behandeln. Also wie man sieht, habe ich ganz unten im Quelltext ein nettes Fenster, was sich beim Klicken auf Schließen öffnet und fragt, ob man das ganze wirklich verlassen möchte.
    Da würde ich gerne einbauen, dass er die Gegenwertigen Integer-Werte des gesamten Spiels in die Datei einspeichert. Also in die andere Richtung.
    ====
  3. Ich hab dann noch vor als Erste Zeile der Textdatei folgendes integriert zu haben:
spielangefangen:1

Da steht dann 1 oder 0, ob ein Spiel zwischengespeichert wurde oder ob ich ein neues Starten möchte.
Also nach dem Motto:

//beziehe die ganzen Spielstandsdaten aus der Textdatei
}
else {
//dann pack ich da den Text rein, wo ganz normal die Startwerte reinkommen, also zum Beispiel:
int punktespieler1 = 0;
int punktespieler2 = 0;
}```

Das schau ich mir mal selbst an, wenn ich da irgendwelche Kollateralitäten feststelle, frage ich einfach nach. Ich überlege mir nur noch, ob ich da einfach alle Werte festlege oder im Fall eines neuen Spiels die Werte auch aus einer Textdatei beziehe. Ich werde mir mal Gedanken machen, was sinnvoller ist.

Schönen Sonntag!
Lukas

Ergänzung: Ich hab das jetzt mal eingebaut, ob er die Datei überhaupt findet:

    BufferedReader reader = new BufferedReader(new FileReader("spielstand.txt"));
    } // end try
    catch (FileNotFoundException ex) {
	System.out.println("Das File wurde nicht gefunden");
	ex.printStackTrace();
	} // end catch```

Nun sagt er mir aber im Text weiter unten: Reader kann nicht aufgelöst werden. Das scheint also nicht so zu klappen, wie ich es mir vorstelle, hm.

Hallo @FranzFerdinand ,

eine Fähigkeit, die man als Programmierer schnell lernen sollte ist, das Rad nicht nochmal zu erfinden.

Deine Datei hat den prinzipiellen Aufbau

schlüssel:wert

Zum Arbeiten mit solchen Dateien kennt Java bereits eine fertige Klasse: [JAPI]Properties[/JAPI]Mit dieser Klasse ändert sich Deine Zeile 37 in Post#3 zuReader reader =new BufferedReader(new FileReader("spielstand.txt")) Properties spielStand= new Properties(); try { spielStand.load(reader ); }catch(FileNotFoundException ex){ ex.printStactrace(); // kann ignoriert werden weil die Datei beim ersten Start noch nicht existiert. } reader.close();
Viel wichtiger ist aber die Änderung in den Zeilen 93 bis 102. Die schrumpfen nämlich zu einer einzigen Zeile:jLabelPunkteSpieler1.setText("Pkt. Spieler 1: "+spielStand.getProperty("punktespieler1"));
Aber die Klase kann noch mehr…
Wenn das Spiel das erste mal gestartet wird ist Deine Spielstand-Datei leer und der Schlüssel wird nicht gefunden. Für diesen Fall soll der Spielstand wahrscheinlich “0” sein. Anstatt jetzt groß überprüfungslogik selbst zu programmieren sagst Du das einfach der aufgerufenen Methode:jLabelPunkteSpieler1.setText("Pkt. Spieler 1: "+spielStand.getProperty("punktespieler1","0"));

Während des Spiels aktualisierst Du das Properties-Object zu passenden Gelegenheitet. Natürlich muss es dazu eine Objektvariable sein (die neue Zeile 38 muss vor den Konstruktor verschoben werden)spielStand.setProperty("punktespieler1",objectFuerSpieler1.getSpielstand());

Am Schluss musst Du den Stand dann noch speichern:spielStand.store(new FileWriter("spielstand.txt"),"wichtiger Kommentar");

bye
TT

[/QUOTE][QUOTE]

[/QUOTE][QUOTE]
Hallöle @Timothy_Truckle ,

Dein Beitrag ist gerade ein Segen für mein Gehirn, meinen Rechner und mein Eclipse. :smiley:
Ich hatte gerade angefangen nach diesem Vorbild von vorhin mit unendlichen if-Anweisungen nachzuprüfen, was wo steht. Ich hatte mir dann irgendwann gedacht:
Bin ich eigentlich doof? Die Datei ist doch immer gleich aufgebaut, wieso überprüft Du dann jede Zeile einzeln? ich war schon am basteln, wie ich das flott realisiere, aber Dein Beitrag kam mir jetzt zuvor. Sieht vollkommen logisch aus.

Ich danke hiermit vorerst für einen mir sehr viel Arbeit abnehmenden Beitrag und probiere das ganze mal aus.

Schönen Sonntag noch.
Ich melde mich, wenn ich das ganze Fertig gebastelt habe.

Gruß
Lukas

Kurze Nebenfrage, die mir jetzt nicht ganz klar ist:
jLabelPunkteSpieler1.setText("Pkt. Spieler 1: "+spielstand.getProperty("punktespieler1","0"));

Der zeigt ja nur an, welcher Wert da drin steht. Ich möchte dann dann liebend gerne wieder in einem Integer zum späteren Rechnen und sowas drin haben.
Wie kann ich das denn kurz und schmerzlos noch in int punktespieler1 umwandeln?

Hallo @FranzFerdinand ,

wenn Du eh gerade am Umbauen bist lies don mal dies:
http://wiki.byte-welt.net/wiki/Warum_man_nicht_von_JFrame/JDialog_erben_sollte

bye
TT

Hallo,

hm, ich bastle gerade an dem Problem mit dem Integer. (falls Du die Änderung am Beitrag oben nicht gesehen haben solltest)
Meinst Du mit dem Hinweis zum Umbauen die Problematik im Kopf meiner Datei, dass ich beispielsweise
setSize(frameWidth, frameHeight);
statt
frame.setSize(frameWidth, frameHeight);
schreibe?

Ich meine Zeile 15 in Post#1.
Deine Klase erbt von JFrame.
Vererbung ist eine ist ein-Bezieung. Dein Spiel soll aber einen JFrame haben.

Leider gibt es (zu) viele Beispiele im Netz die genau so aufgebaut sind.

bye
TT

[QUOTE=Timothy_Truckle;103925]Ich meine Zeile 15 in Post#1.
Deine Klase erbt von JFrame.
Vererbung ist eine ist ein-Bezieung. Dein Spiel soll aber einen JFrame haben.

Leider gibt es (zu) viele Beispiele im Netz die genau so aufgebaut sind.

bye
TT[/QUOTE]
Achso, hm, ja, ist im Status quo halt so. Vielen dank für den Hinweis, wenn ich mich mit Vererbung beschäftige ändere ich das.
Solange es keine Probleme macht, ist das jedoch keine Dringlichkeit.

Zu meinem anderen Problem zurück:

int variable1 = Integer.parseInt(string1);```

Ich arbeite immer noch an dem Problem, dass ich mit dem bisherigen Code zwar die Labels ausfülle, aber keine Variablen fülle. Der Text da oben läuft irgendwie nicht, wie er soll. Muss ich etwas spezielles beachten, was mir hier das Genick bricht?

[quote=FranzFerdinand]Der Text da oben läuft irgendwie nicht, wie er soll.[/quote]Bitte beschreibe dein Problem genauer:
[ul]
[li]wie genau weicht Dein Programm von Deiner Erwartung ab?
[/li][li]Gibt es eine Fehlermeldung vom Compiler? (Bitte posten)
[/li][li]Gibt es eine Fehlermeldung zur Laufzeit? (Bitte posten)
[/li][/ul]
bye
TT

Huch huch, ich hatte mich vorhin banal mit Klammern und mit der Groß- und Kleinschreibung verhauen. Läuft nun, wie es soll, Tatsache.

Also, es steht jetzt so da:

    int variable1 = Integer.parseInt(string1);
    variable1 = variable1 + 8; //ist nur ein Beispiel, dass ich sehe, dass man die Variable verrechnen kann
    jLabelRestkartenTisch.setText("Resttische: "+variable1);
    jLabelRestkartenGast.setText("Restgäste: "+spielstand.getProperty("restkartengast","0"));
    jLabelRestbarplaetze.setText("Barplätze übrig: "+spielstand.getProperty("restbarplaetze","21"));
    jLabelHandkartenSpieler1.setText("Karten Spieler 1: "+spielstand.getProperty("handkartenspieler1","0"));
    jLabelHandkartenSpieler2.setText("Karten Spieler 2: "+spielstand.getProperty("handkartenspieler2","0"));
    jLabelPunkteSpieler1.setText("Pkt. Spieler 1: "+spielstand.getProperty("punktespieler1","0"));
    jLabelPunkteSpieler2.setText("Pkt. Spieler 2: "+spielstand.getProperty("punktespieler2","0"));
    jLabelSpieler.setText("Am Zug: Spieler "+spielstand.getProperty("spieler","1"));```

Sind 8 Labels, am Beispiel des Ersten Labels hab ich es jetzt nochmal schnell umgeformt, wie ich es möchte. Also er liest den Wert aus, schreibt ihn in einen String, wandeln diesen in einen Integer um und gibt ihn dann im Label aus. Läuft. Müsste ich bei allem auch noch machen.

Letzte Frage für heute:
Kann ich das seriös mit Arrays oder Platzhaltern verbinden, dass ich nicht extra die beiden Obersten Zeilen für jeden Wert einfügen muss?
```String string1 = spielstand.getProperty("restkartentisch");
    int variable1 = Integer.parseInt(string1);```

Also er soll automatisch alle Teile vor dem Doppelpunkt in der Textdatei in einen Integer schreiben, der den gleichen Namen trägt.
Also:

gastkarten:100
laenderkarten:24
spieleramzug:2
punktespieler1:37
punktespieler2:45


Er erkennt, Aha, da sind 5 Werte, ich erstelle folgende Werte:
```int gastkarten = 100;
int laenderkarten = 24;
int spieleramzug = 2;
//usw.```


Gruß
Lukas

Der normale Weg, sich wiederholenden Code einzusparen ist, eine Methode zu schreiben, die die sich wiederholenden Operationen aufnimmt: ```//…
int variable1=getIntAndSetLable(new JLable("Resttische: "),“restkartentisch”,“0”);
//…

// später in der Klasse
private int getIntAndSetLable(JLable lable, String key, String defaultValue){
String value = spielStand.getProperty(key, defaultValue);
lable.setTest(lable.getText()+value); // hier muss noch optimiert werden damit säter die values ersetzt und nicht alle einfach angehangen werden
return Integer.paseInt(value);
}```

bye
TT

Einen wunderschönen Guten Tag,

ich habe mich zwischenzeitlich mit einem anderen kleinen Problem befasst, was nun wunderbar läuft und muss nun nochmal hier nachfragen.
Das Speichermanagement in meinem Projekt läuft hervorragend, sowohl das auslesen, als auch das abspeichern.
Ich habe es ehrlich gesagt immer noch nicht hinbekommen pauschal alle Werte der Textdatei abzufragen, aber das ist erstmal nicht weiter wild, ich frage sie halt alle einzeln ab. Tut erstmal keinen Zwang.
Wie ich nun die Werte auslese, ist mir bekannt.
Jedoch würde ich gerne eine Sache noch wissen, die unentbehrlich für mein Speichermanagement ist.

Ich lasse die Liste meiner 100 Gastkarten in einer Liste speichern und dann in einer jList ausgeben.
Das ganze habe ich hier in diesem Thema erledigt: http://forum.byte-welt.net/threads/13191-jList-Shuffle/page2?p=104814&viewfull=1#post104814

Ich würde an dieser Stelle gerne wissen, wie ich ganze Listen sinnvoll und ohne größere Aufwände mit in die Textdatei abspeichere und auch wieder einlese.
Wie gesagt, es sind 100 Werte, da jetzt irgendwie alles einzeln versuchen abzuspeichern, wie ich es bisher gemacht habe, wäre fahrlässig und dumm.

Meine Javadatei sieht folgendermaßen aus:


import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.util.*;
import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTextField;
import javax.swing.WindowConstants;
import static spiel.Gastkarte.*;

public class CafeRoot extends JFrame {

  private static final long serialVersionUID = 2463407896592093246L;
  // Anfang Attribute
  private int spielangefangen = 0;
  private int restkartentisch = 0;
  private int restkartengast = 0;
  private int restbarplaetze = 0;
  private int handkartenspieler1 = 0;
  private int handkartenspieler2 = 0;
  private int punktespieler1 = 0;
  private int punktespieler2 = 0;
  private int spieler = 0;
  private String spielername1 = "Spieler 1";
  private String spielername2 = "Spieler 2";
  private List<Gastkarte> gastkarten = new ArrayList<Gastkarte>();
  private JList<Gastkarte> jListGastkarten = new JList<Gastkarte>();
  private DefaultListModel<Gastkarte> jListGastkartenModel = new DefaultListModel<Gastkarte>();
  private JScrollPane jListGastkartenScrollPane= new JScrollPane(jListGastkarten);
  private JLabel jLabelRestkartenTisch = new JLabel();
  private JLabel jLabelRestkartenGast = new JLabel();
  private JLabel jLabelRestbarplaetze = new JLabel();
  private JLabel jLabelHandkartenSpieler1 = new JLabel();
  private JLabel jLabelHandkartenSpieler2 = new JLabel();
  private JLabel jLabelPunkteSpieler1 = new JLabel();
  private JLabel jLabelPunkteSpieler2 = new JLabel();
  private JLabel jLabelSpieler = new JLabel();
  private boolean spielernamenkorrekt = false;
  private JButton jButtonNeustart = new JButton();
  // Ende Attribute
  
  public CafeRoot(String title) throws IOException {
    // Frame-Initialisierung
    super(title);
    setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    Reader reader = new BufferedReader(new FileReader("neuesspiel.txt"));
    Properties neuesspiel = new Properties();
    try {
      neuesspiel.load(reader);
    }catch(FileNotFoundException ex){
       ex.printStackTrace();
       System.out.println("Die Datei neuesspiel.txt existiert nicht!");
    }
    reader.close();
    Reader reader2 = new BufferedReader(new FileReader("spielstand.txt"));
    Properties spielstand = new Properties();
    try {
      spielstand.load(reader2);
    }catch(FileNotFoundException ex){
       ex.printStackTrace();
       System.out.println("Die Datei spielstand.txt existiert nicht!");
    }
    reader.close();
    int frameWidth = 506; 
    int frameHeight = 434;
    setSize(frameWidth, frameHeight);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    int x = (d.width - getSize().width) / 2;
    int y = (d.height - getSize().height) / 2;
    setLocation(x, y);
    setResizable(false);
    Container cp = getContentPane();
    setTitle("Café International");
    setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
    setLocationRelativeTo(null);
    cp.setLayout(null);
    
    // Anfang Komponenten
    jLabelRestkartenTisch.setBounds(25, 10, 100, 30);
    cp.add(jLabelRestkartenTisch);
    jLabelRestkartenGast.setBounds(25, 35, 100, 30);
    cp.add(jLabelRestkartenGast);
    jLabelRestbarplaetze.setBounds(25, 60, 120, 30);
    cp.add(jLabelRestbarplaetze);
    jLabelHandkartenSpieler1.setBounds(25, 85, 140, 30);
    cp.add(jLabelHandkartenSpieler1);
    jLabelHandkartenSpieler2.setBounds(25, 110, 140, 30);
    cp.add(jLabelHandkartenSpieler2);
    jLabelPunkteSpieler1.setBounds(25, 135, 140, 30);
    cp.add(jLabelPunkteSpieler1);
    jLabelPunkteSpieler2.setBounds(25, 160, 140, 30);
    cp.add(jLabelPunkteSpieler2);
    jLabelSpieler.setBounds(25, 185, 140, 30);
    cp.add(jLabelSpieler);
    jListGastkarten.setModel(jListGastkartenModel);
    jListGastkartenScrollPane.setBounds(25, 210, 300, 100);
    cp.add(jListGastkartenScrollPane);
    jButtonNeustart.setBounds(320, 16, 105, 41);
    jButtonNeustart.setText("Nouveau!");
    jButtonNeustart.setMargin(new Insets(2, 2, 2, 2));
    jButtonNeustart.addActionListener(new ActionListener() { 
      public void actionPerformed(ActionEvent evt) { 
        try {
			jButtonNeustart_ActionPerformed(evt);
		} catch (IOException e) {
			e.printStackTrace();
		}
      }
    });
    cp.add(jButtonNeustart);
    //=============================
    String string_spielangefangen = spielstand.getProperty("spielangefangen", "0");
    int spielangefangen = Integer.parseInt(string_spielangefangen);
    if(spielangefangen == 0) {
    	do{
    		namensfrage();
    	}while(spielernamenkorrekt == false);
    	System.out.println("Spieler 1 heißt: "+spielername1);
        System.out.println("Spieler 2 heißt: "+spielername2);
    	neuesspiel();
    	gastkartenmischen();
    }
    else{
    	spielstand();
    }
    // Ende Komponenten
    
    setVisible(true);
    addWindowListener(new MyWindowListener(this, spielstand));
    //=============================
    
    Random wuerfel1 = new Random(); //Würfeltest
    int wuerfel = wuerfel1.nextInt(49)+1; //Würfeltest
    System.out.println(wuerfel);
  }
  
  // Anfang Methoden
  
  public void jButtonNeustart_ActionPerformed(ActionEvent evt) throws IOException {
	  final JFrame Neustart = new JFrame("Ein Frame zum Schließen");
      Neustart.setTitle("Spiel neustarten");
      Object[] options = {"Neustarten", "Abbrechen"};
      int neustart = JOptionPane.showOptionDialog(null,
      "Möchtest Du das Spiel wirklich neustarten?
Dein Spielstand wird verloren gehen!",
      "Café International neustarten?",
      JOptionPane.DEFAULT_OPTION, 
      JOptionPane.QUESTION_MESSAGE, 
      null, options, options[0]);
      if(neustart == 0) {
    	  gastkarten.clear();
    	  jListGastkartenModel.clear();
    	  neuesspiel();
    	  gastkartenmischen();
      }
  }
  private void neuesspiel() throws IOException{
	  Reader reader = new BufferedReader(new FileReader("neuesspiel.txt"));
	    Properties neuesspiel = new Properties();
	    try {
	      neuesspiel.load(reader);
	    }catch(FileNotFoundException ex){
	       ex.printStackTrace();
	       System.out.println("Die Datei neuesspiel.txt existiert nicht!");
	    }
	    reader.close();
	  String string_restkartentisch = neuesspiel.getProperty("restkartentisch", "24");
      restkartentisch = Integer.parseInt(string_restkartentisch);
      jLabelRestkartenTisch.setText("Resttische: "+restkartentisch);
      String string_restkartengast = neuesspiel.getProperty("restkartengast", "0");
      restkartengast = Integer.parseInt(string_restkartengast);
      jLabelRestkartenGast.setText("Restgäste: "+restkartengast);
      String string_restbarplaetze = neuesspiel.getProperty("restbarplaetze", "21");
      restbarplaetze = Integer.parseInt(string_restbarplaetze);
      jLabelRestbarplaetze.setText("Barplätze übrig: "+restbarplaetze); 
      String string_handkartenspieler1 = neuesspiel.getProperty("handkartenspieler1", "0");
      handkartenspieler1 = Integer.parseInt(string_handkartenspieler1);
      jLabelHandkartenSpieler1.setText("Karten "+spielername1+": "+handkartenspieler1);
      String string_handkartenspieler2 = neuesspiel.getProperty("handkartenspieler2", "0");
      handkartenspieler2 = Integer.parseInt(string_handkartenspieler2);
      jLabelHandkartenSpieler2.setText("Karten "+spielername2+": "+handkartenspieler2);
      String string_punktespieler1 = neuesspiel.getProperty("punktespieler1", "0");
      punktespieler1 = Integer.parseInt(string_punktespieler1);
      jLabelPunkteSpieler1.setText("Punkte "+spielername1+": "+punktespieler1);
      String string_punktespieler2 = neuesspiel.getProperty("punktespieler2", "0");
      punktespieler2 = Integer.parseInt(string_punktespieler2);
      jLabelPunkteSpieler2.setText("Punkte "+spielername2+": "+punktespieler2);
      String string_spieler = neuesspiel.getProperty("spieler", "1");
      spieler = Integer.parseInt(string_spieler);
      if(spieler == 1){
      	jLabelSpieler.setText("Am Zug: "+spielername1);
      }
      else{
      	jLabelSpieler.setText("Am Zug: "+spielername2);
      }
      System.out.println("Neues Spiel gestartet");
  }
  private void spielstand() throws IOException{
	  Reader reader2 = new BufferedReader(new FileReader("spielstand.txt"));
	  Properties spielstand = new Properties();
	  try {
	    spielstand.load(reader2);
	  }catch(FileNotFoundException ex){
	     ex.printStackTrace();
	     System.out.println("Die Datei spielstand.txt existiert nicht!");
	  }
	  reader2.close(); 
	  JOptionPane.showMessageDialog(null, "Ein Zwischengespeichertes Spiel wird wiederhergestellt!", "Weiterspielen", JOptionPane.INFORMATION_MESSAGE);
      String spielername1 = spielstand.getProperty("spielername1", "Nicht vorhanden");
      String spielername2 = spielstand.getProperty("spielername2", "Nicht vorhanden");
  	  String string_restkartentisch = spielstand.getProperty("restkartentisch", "0");
      restkartentisch = Integer.parseInt(string_restkartentisch);
      jLabelRestkartenTisch.setText("Resttische: "+restkartentisch);
      String string_restkartengast = spielstand.getProperty("restkartengast", "0");
      restkartengast = Integer.parseInt(string_restkartengast);
      jLabelRestkartenGast.setText("Restgäste: "+restkartengast);
      String string_restbarplaetze = spielstand.getProperty("restbarplaetze", "21");
      restbarplaetze = Integer.parseInt(string_restbarplaetze);
      jLabelRestbarplaetze.setText("Barplätze übrig: "+restbarplaetze); 
      String string_handkartenspieler1 = spielstand.getProperty("handkartenspieler1", "0");
      handkartenspieler1 = Integer.parseInt(string_handkartenspieler1);
      jLabelHandkartenSpieler1.setText("Karten "+spielername1+": "+handkartenspieler1);
      String string_handkartenspieler2 = spielstand.getProperty("handkartenspieler2", "0");
      handkartenspieler2 = Integer.parseInt(string_handkartenspieler2);
      jLabelHandkartenSpieler2.setText("Karten "+spielername2+": "+handkartenspieler2);
      String string_punktespieler1 = spielstand.getProperty("punktespieler1", "0");
      punktespieler1 = Integer.parseInt(string_punktespieler1);
      jLabelPunkteSpieler1.setText("Punkte "+spielername1+": "+punktespieler1);
      String string_punktespieler2 = spielstand.getProperty("punktespieler2", "0");
      punktespieler2 = Integer.parseInt(string_punktespieler2);
      jLabelPunkteSpieler2.setText("Punkte "+spielername2+": "+punktespieler2);
      String string_spieler = spielstand.getProperty("spieler", "1");
      spieler = Integer.parseInt(string_spieler);
      if(spieler == 1){
      	jLabelSpieler.setText("Am Zug: "+spielername1);
      }
      else{
      	jLabelSpieler.setText("Am Zug: "+spielername2);
      }
      System.out.println("Ein altes Spiel wurde wiederhergestellt");
  }
  private void namensfrage() {
	  JTextField spielername01 = new JTextField(new MaxSizeDocument(12), "", 0);
	  JTextField spielername02 = new JTextField(new MaxSizeDocument(12), "", 0);
      Object[] namensfrage = {"Name von Spieler 1", spielername01, "Name von Spieler 2", spielername02};
      JOptionPane pane = new JOptionPane(namensfrage, JOptionPane.PLAIN_MESSAGE, JOptionPane.DEFAULT_OPTION);
      pane.createDialog(null, "Wie heißen die Spieler?").setVisible(true);
      spielername1 = spielername01.getText();
      spielername2 = spielername02.getText();
      if(spielername1.equals("") || spielername2.equals("")) {
    	  JOptionPane.showMessageDialog(null, "Bitte gib beide Spielernamen ein!", "Unvollständige Eingabe", JOptionPane.ERROR_MESSAGE);
    	  System.out.println("Es wurden nicht alle Spielernamen eingetragen");
    	  namensfrage(); 
  	  }
      else if(spielername1.equalsIgnoreCase(spielername2)) {
    	  JOptionPane.showMessageDialog(null, "Bitte benenne die Spieler unterschiedlich!", "Namensgleichheit", JOptionPane.ERROR_MESSAGE);
    	  System.out.println("Es wurde bei beiden Namen \""+spielername1+"\" eingetragen");
    	  namensfrage(); 
      }
      else{
    	  spielernamenkorrekt = true;
      }
  }
  private void gastkartenmischen() {
	  for(int j=0;j<2;j++){
	    	for(Land land : Land.values()) {
	            int anzahl = 2;
	            if (land == Land.Joker) {
	               anzahl = 1;
	            }
	            for(int i = 0; i < anzahl; i++) {
	                for(Geschlecht geschlecht : Geschlecht.values()) {
	                    gastkarten.add(new Gastkarte(geschlecht, land));
	                    restkartengast = restkartengast + 1;
	                }    
	            }
	        }
	    }
	  	
	  	/*Gastkarte eineGastkarte = gastkarten.get(0);
	  	Geschlecht geschlecht = eineGastkarte.geschlecht;
	  	Land land = eineGastkarte.land;
	    
	    if(land == Land.Chinese) {
	       System.out.println("Nihao!");
	    }*/
	    jLabelRestkartenGast.setText("Restgäste: "+restkartengast);
	    Collections.shuffle(gastkarten);
	    for(int n=0;n<gastkarten.size();n++){
	    	jListGastkartenModel.addElement(gastkarten.get(n));
	    }
	    System.out.println("Die Gastkarten wurden gemischt");
	    System.out.println(gastkarten);
  }
  // Ende Methoden
  
  public static void main(String[] args) throws IOException {
    new CafeRoot("CafeRoot");
  } // end of main 
  public class MyWindowListener implements WindowListener {
    private Properties spielstand;
    private CafeRoot cRoot;
    
    public MyWindowListener(CafeRoot cRoot,Properties spielstand) {
      this.cRoot = cRoot;
      this.spielstand = spielstand;
    }
    
    @Override
    public void windowActivated(WindowEvent arg0) { }
    
    @Override
    public void windowClosed(WindowEvent arg0) {
      cRoot.setVisible(false);  
    }
    
    @Override
    public void windowClosing(WindowEvent evt)
    {
      final JFrame Beenden = new JFrame("Ein Frame zum Schließen");
      Beenden.setTitle("Spiel beenden");
      Object[] options = {"Speichern", "Beenden", "Abbrechen"};
      int beenden = JOptionPane.showOptionDialog(null,
      "Möchtest Du das Spiel wirklich beenden?
Dein Spielstand wird verloren gehen!",
      "Café International beenden?",
      JOptionPane.DEFAULT_OPTION, 
      JOptionPane.QUESTION_MESSAGE, 
      null, options, options[0]);
      if(beenden == 0)
      {
      try {
        spielangefangen = 1;
        spielstand.setProperty("spielangefangen",spielangefangen + "");
        spielstand.setProperty("restkartentisch",restkartentisch + "");
        spielstand.setProperty("restkartengast",restkartengast + "");
        spielstand.setProperty("restbarplaetze",restbarplaetze + "");
        spielstand.setProperty("handkartenspieler1",handkartenspieler1 + "");
        spielstand.setProperty("handkartenspieler2",handkartenspieler2 + "");
        spielstand.setProperty("punktespieler1",punktespieler1 + "");
        spielstand.setProperty("punktespieler2",punktespieler2 + "");
        spielstand.setProperty("spielername1",spielername1);
        spielstand.setProperty("spielername2",spielername2);
        spielstand.setProperty("spieler",spieler + "");
        spielstand.store(new FileWriter("spielstand.txt"),"Gespeichertes Spiel");
        System.out.println("Das Spiel wurde beendet und der Spielstand abgespeichert");
    } catch (IOException e) {
      e.printStackTrace();
    }
        System.exit(0);
      }
      else{
        if(beenden == 1) {
        	try {
        		spielangefangen = 0;
        		spielstand.setProperty("spielangefangen",spielangefangen + "");
				spielstand.store(new FileWriter("spielstand.txt"),"Keine Speicherdatei");
				System.out.println("Das Spiel wurde beendet, aber kein Spielstand gespeichert");
			} catch (IOException e) {
				e.printStackTrace();
			}
          System.exit(0);
        }
      }
    }
    
    @Override
    public void windowDeactivated(WindowEvent arg0) { }
    @Override
    public void windowDeiconified(WindowEvent arg0) { }
    @Override
    public void windowIconified(WindowEvent arg0) { }
    @Override
    public void windowOpened(WindowEvent arg0) { }
    
    
  }
} // end of class CafeRoot

Die Klasse Gastkarte hat diesen Inhalt:


public class Gastkarte {
	   public static enum Geschlecht {männlich, weiblich};
	   public static enum Land {Deutscher, Franzake, Brite, Amerikaner, Türke, Inder, Chinese, Russe, Spanier, Kubaner, Afrikaner, Italiener, Joker};
	 
	   public final Land land;
	   public final Geschlecht geschlecht;
	 
	   public Gastkarte(Geschlecht geschlecht, Land land){
	      this.land = land;
	      this.geschlecht= geschlecht;
	   }
	 
	   public String toString(){
	     return land + ":" + geschlecht;
	   }
	}

Nun überlege ich 1. wie ich das ganze abspeichern möchte und 2. wie ich das Codetechnisch bewerkstellige.
Ich hätte zwei Varianten als Ideen:
er speichert entweder in 100 Zeilen jeweils Paare ab: gastkarte1:deutscher,männlich;gastkarte2:brite,weiblich.
Das ist natürlich umständlich und hat sicherlich eine längere Laufzeit.
Eine Alternatividee wäre, dass er nach dem Altbekannten Modell absucht, wo gastkarten: steht und dann getrennt durch Kommata oder Semikola alle 100 auflistet: gastkarten:brite,männlich;deutscher,männlich;ami,weiblich
Das zweite wäre natürlich sicherlich Speicherplatzärmer und mit einer besseren Laufzeit behaftet.

Hat jemand eine kluge Idee, wie man das alles nett umsetzen kann?
Zu beachten: Es handelt sich um Gastkarten, die aus zwei Elementen bestehen, also Land und Geschlecht, es darf nicht sein, dass diese nach dem Wiederherstellen ein einziger Einheitsbrei sind, die sich nicht mehr getrennt voneinander behandeln und abfragen lassen.

Danke und einen schönen Tag noch.

Bussy
Lukas

Eintrag enthält bisschen wenig Infos,
gibt es unter den 100 auch Doppelte oder mindesten 50 verschiedene Länder + m/w?
wobei die Enum nicht viel erlaubt, dann wohl Doppelte,
na ist ja auch egal, kürzer gehts kaum, außer eben noch m/w als einzelne Buchstaben einzuführen,

wenn m/wm immer der erste Buchstabe ist könnte man dahinter Semikolon auch sparen usw., Spitzfindigkeiten

ob jeder Eintrag in einer Zeile oder noch ein Trennsymbol dazwischen ist beliebig (Zeilenumbruch ist auch ein Zeichen)

gastkarte vor jedem Eintrag, ob mit oder ohne Nummerierung, scheint überflüssig, falls nicht von anderen Einträgen zu unterscheiden ist,
Computer weiß die Nummerierung auch so, Textprogramme bei Zeilen ebenfalls, sonst für menschlichen Leser vielleicht noch hilfreich

am Anfang der Datei 1x gastkarte oder eine Kommentarzeile oder sonst irgendwas kann man machen oder auch ganz weglassen wenn z.B. Dateiname ausreicht,
alles ziemlich beliebig, da gibt es nicht viel zu empfehlen, jedenfalls keine wichtigen Best Practice


bei 100 Einträgen kann man auch die Datei immer komplett neu schreiben,
wenn es 50 MB wären schadet es nicht drauf zu achten, dass ein simples Hinzufügen eines neuen Eintrags möglich ist, wäre sparsam,
kann dann neben neuen Einträgen auch eine Info ‘Eintrag 45.678 ist eigentlich gelöscht’ sein statt ganze 50 MB ohne diesen Eintrag neu zu schreiben

deine Varianten erlauben das jeweils, aber wie gesagt auch nicht wichtig

Hallo und vielen Dank für Deine Antwort,

das soll eigentlich eine einzelne Speicherdatei sein, wie ich sie eingangs des gesamten Themas hier erstellt habe. Keine neue Extradatei. Eine einzige Textdatei, die den gesamten Speicherstand notiert.
Es handelt sich um 13 Länder und 2 Geschlechter, die in Einzelkombination je 4 mal auftreten. 2134= 104 (Es gibt nur 2 statt 4 Joker) -> 100 Karten sind das.

Die werden, wie man im Code sieht in eine List gemischt und dann in die jList eingefügt. Und diese würde ich gerne in die Speicherdatei reinschreiben und wieder auslesen.

Gruß
Lukas

Wenn es ein festes Set an Karten gibt würde ich die programmatisch erzeugen und nicht aus einer Datei lesen.

bye
TT

[QUOTE=Timothy_Truckle;104829]Wenn es ein festes Set an Karten gibt würde ich die programmatisch erzeugen und nicht aus einer Datei lesen.
[/QUOTE]

Hallöle,

klar, die Karten werden auch im Programm erzeugt, kannste im Code unter der Methode gastkartenmischensehen.
Ich möchte jedoch wie gesagt gerne anbieten, dass man seinen Spielstand zwischenspeichern kann.
Das geht ja nun für einzelne Werte. Aber das macht ja keinen Sinn, wenn ich nicht auch die Karten, die die Spieler haben zwischenspeichern kann.

Gruß
Lukas

Ein mögliche Alternative - sobald etwas mehr Programmiererfahrung und Kenntnisse der Objektorientierung vorliegen - könnte die Serialisierung sein. Wenn Du ein Model verwendest in dem der Spielstand verwaltet wird, könnte man dieses Objekt einfach in eine Datei serialisieren und bei Bedarf wieder deserialisieren.

In deinem Fall, auch da die Daten nicht sonderlich komplex sind ist es aber vermutlich geschickter diese selbst in eine Datei zu schreiben und da ist es egal, ob alles in eine Zeile oder eine Zeile pro Info.
Evtl. könnte man das auch gleich in Form eines xmls machen, dann wäre es m.M. etwas besser lesbar - falls das überhaupt gewünscht ist.

********Naja. Irgendwie wird das schon gehen. Ich präferiere ja einfach mal, dass er das gleich in die vorhandene Datei dahinter schreibt, in Reihenfolge und das dann aufzählt.
Aber wie auch immer, ich habe keine Ahnung, wie das überhaupt zu losen sein soll.
Hat da jemand eine Idee?

Ich hab selbst mal ein bisschen gebastelt und eine ganz seltsame Idee gehabt, die logischerweise auch gar nicht funktioniert, wie ich es mir gedacht habe.

        	spielstand.setProperty("gastkarten",gastkarten[n]+";");
        }```

Der sollte eigentlich die Anzahl der Gastkarten durchzählen und jede einzeln brav einfügen. Also die Gastkarte an der Stelle n. Von 0 bis 99 für die 100 Stück also.
Aber meine Gastkartenliste unterstützt ja sowas Arrayartiges eh nicht.:eek:

Gruß
Lukas

PS: Hatte ich ganz vergessen, das `+";"` fungiert als Trennzeichen, damit man das dann auch, wie auch immer, wieder einlesen kann und aus den Karten kein Einheitsbrei geworden ist.