# ArrayList in Datei speichern und auslesen



## Todo (9. Feb 2009)

Hi @ all,
habe folgendes Problem, und zwar speicher ich meine Objekte in eine ArrayList und zwar so:

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

public class Liste_Objekte {
    File file = new File("list.bin");
    ArrayList <TippSpieler> objekte;

    Liste_Objekte(){
        objekte = new ArrayList <TippSpieler>();
    }

    public void add_objekt(TippSpieler to){
        objekte.add(to);
    }

    public TippSpieler sucheObjekt(String name){
        for(TippSpieler  to: objekte){
            if(to.getName().equalsIgnoreCase(name))
            return to;
        }
       return null;
    }

    public void speichern() {
     
    }

    public void einlesen() {
  
    }
}
```

Wie man sieht möchte ich jetzt noch eine Methode speichern und eine Methode einlesen schreiben. Im Objekt TippSpieler stehen folgende Attribute:

 string name
        int richtig
        int tendenz
        int falsch
        int nr
So jetzt habe ich gelesen man kann es Serializable machen, er hat auch schonmal abgespeichert aber das einlesen Funktioniert gar nicht. Kann mir jemand helfen? Danke schonmal im voraus.


----------



## hdi (9. Feb 2009)

mal ein anderer Tipp am Rande:


```
public TippSpieler sucheObjekt(String name){
        for(TippSpieler  to: objekte){
            if(to.getName().equalsIgnoreCase(name))
            return to;
        }
       return null;
    }
```

ist eher unüblich, bzw. es geht besser. Und zwar hat eine ArrayList die Methode
contains(), mit der du prüfen kannst ob ein gegebenes Objekt drinliegt.

contains() basiert auf eqals(), d.h. du überschreibst in deiner Klasse* TippSpieler* diese Methode:


```
@Override
public boolean equals(Object other){
     TippSpieler o = (TippSpieler)other;
     if(o == null) return false;
     return this.getName().equalsIgnoreCase(o.getName());
}
```

...und jetzt kannst du die Methode sucheObjekt weglassen und bequem machen:


```
objekte.contains(eintippspieler);
```

edit: Sry anscheinend willst du ein Objekt anhand des Namens haben, hab das nicht
ganz überrissen 

Zum Topic: Ich kann dir sagen wie du einfach die Daten in eine Datei speicherst, und ausliest,
aber ich weiss nicht was du mit Serializable grad meinst. Ich kenn das nur im Zusammenhang mit
Netzwerk


----------



## Todo (9. Feb 2009)

hmm hab das nur so aufgegriffen mir würd voll kommen reichen in Datei speichern und wieder einlesen egal wie ^^


----------



## Ariol (9. Feb 2009)

Was dir lieber ist:


```
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException
	{
		ArrayList<JButton> ba = new ArrayList<JButton>();
		ba.add(new JButton("1"));
		ba.add(new JButton("2"));
		ba.add(new JButton("3"));
		
		//ObjectOutput/InputStream
		File sf = new File("serialized.obj");
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(sf));
		oos.writeObject(ba);
		oos.close();
		
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(sf));
		ba = (ArrayList<JButton>) ois.readObject();
		ois.close();

		//Testausgabe
		System.out.println("Aus " + sf.getName() + ":");
		for(JButton b : ba)System.out.println(b.getText());
		
		//XMLEncoder/Decoder
		File xf = new File("serialized.xml");
		XMLEncoder xEnc = new XMLEncoder(new FileOutputStream(xf));
		xEnc.writeObject(ba);
		xEnc.close();
		
		XMLDecoder xDec = new XMLDecoder(new FileInputStream(xf));
		ba = (ArrayList<JButton>) xDec.readObject();
		xDec.close();

		//Testausgabe
		System.out.println("Aus " + xf.getName() + ":");
		for(JButton b : ba)System.out.println(b.getText());
	}
```


----------



## Todo (9. Feb 2009)

Danke werde ich gleich mal auf mein Programm probieren.
Hm irgendwie habe ich echt schwierigkeiten das in mein Programm zu intergrieren.
Bin leider anfänger   kann mir jemand helfen? also was muss in meine Methode speichern und was in einlesen ? Sry  

Habe es jetzt so probiert:


```
public void speichern(TippSpieler to) throws FileNotFoundException, IOException, ClassNotFoundException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(sf));
        oos.writeObject(to);
        oos.close();
    }

    public void einlesen()throws FileNotFoundException, IOException, ClassNotFoundException {
       ObjectInputStream ois = new ObjectInputStream(new FileInputStream(sf));
       ArrayList ba = (ArrayList<TippSpieler>) ois.readObject();
       ois.close();
    }
```

und in der Main dann so aufgerunfen list.einlesen(); und will es dann wieder in der Liste speichern.
Jedoch als erstes, wie kann ich die ArrayListe denn zur Main zurückgeben sodass die in der list gespeichert wird? Es wird ja jetzt in eine neue liste ba gespeichert und ihr gibt mir immer eine Exeption beim einlesen und zwar:

```
Exception in thread "main" java.lang.ClassCastException: tippspiel.TippSpieler cannot be cast to java.util.ArrayList
        at tippspiel.Liste_Objekte.einlesen(Liste_Objekte.java:34)
        at tippspiel.Main.main(Main.java:16)
Java Result: 1
```


----------



## ARadauer (10. Feb 2009)

tja du schreibst einen TippSpieler und ließt ein ArrayList<TippSpieler>

wie zu erwarten der Fehler ->TippSpieler cannot be cast to java.util.ArrayList


----------



## max60watt (10. Feb 2009)

Hallo Todo,

nachfolgend ein Beispiel zum Schreiben und Lesen von ArrayList.

Das ArrayList wird einmal als Binärdatei gespeichert, zum Anderen als xml-Datei.

Hier die Klasse TippSpieler zum Speichern als Binär-File


```
import java.io.*;

public class TippSpieler implements Serializable{
String name;
int richtig; 
int tendenz; 
int falsch;
int nr;
//---------------------------------------------------------------------------
  public TippSpieler(String name, int richtig, int tendenz, int falsch, int nr){
    this.name = name;
    this.richtig = richtig; 
    this.tendenz = tendenz; 
    this.falsch = falsch;
    this.nr = nr;
  }
//---------------------------------------------------------------------------
  public String toString(){
    return String.format("Name: %s \t Richtig: %d \t Tendenz: %d \t Falsch: %d \t Nr: %d", name,richtig,tendenz,falsch,nr);
  }
//---------------------------------------------------------------------------
}
```
Jetzt die Klasse TippSpielerXML zum Speichern als XML-File Hierbei ist zu beachten, das ein leerer Konstruktor vorhanden ist und auch alle Getter und Setter.

```
import java.io.*;

public class TippSpielerXML implements Serializable{
String name;
int richtig; 
int tendenz; 
int falsch;
int nr;
//---------------------------------------------------------------------------
  public TippSpielerXML(){
// leerer Construktor für XMLEncoder
  }
//---------------------------------------------------------------------------
  public TippSpielerXML(String name, int richtig, int tendenz, int falsch, int nr){
    this.name = name;
    this.richtig = richtig; 
    this.tendenz = tendenz; 
    this.falsch = falsch;
    this.nr = nr;
  }
//---------------------------------------------------------------------------
  public String getName(){
    return name;
  }
//---------------------------------------------------------------------------
  public int getRichtig(){
    return richtig;
  }
//---------------------------------------------------------------------------
  public int getTendenz(){
    return tendenz;
  }
//---------------------------------------------------------------------------
  public int getFalsch(){
    return falsch;
  }
//---------------------------------------------------------------------------
  public int getNr(){
    return nr;
  }
//---------------------------------------------------------------------------
  public void setName(String n){
    this.name = n;
  }
//---------------------------------------------------------------------------
  public void setRichtig(int i){
    this.richtig = i;
  }
//---------------------------------------------------------------------------
  public void setTendenz(int i){
    this.tendenz = i;
  }
//---------------------------------------------------------------------------
  public void setFalsch(int i){
    this.falsch = i;
  }
//---------------------------------------------------------------------------
  public void setNr(int i){
    this.nr = i;
  }
//---------------------------------------------------------------------------
  public String toString(){
    return String.format("Name: %s \t Richtig: %d \t Tendenz: %d \t Falsch: %d \t Nr: %d", name,richtig,tendenz,falsch,nr);
  }
//---------------------------------------------------------------------------
}
```
Jetzt die Klasse zum Speichern der ArrayList

```
import java.util.*;
import java.io.*;
import java.beans.*;

class WriteTippSpieler{
List<TippSpieler> listeTippSpieler = new ArrayList<TippSpieler>();
List<TippSpielerXML> listeTippSpielerXML = new ArrayList<TippSpielerXML>();
//---------------------------------------------------------------------------
  public WriteTippSpieler(){
    init();
    save();
    saveXML();
  }
//---------------------------------------------------------------------------
  private void init(){
    listeTippSpieler.add(new TippSpieler("Hans", 1,11,111,0));
    listeTippSpieler.add(new TippSpieler("Maria", 9,-22,8,1));
    listeTippSpieler.add(new TippSpieler("Kurt", 0,66,32100,2));
    listeTippSpieler.add(new TippSpieler("Claudia", 2,139,6000,3));

    listeTippSpielerXML.add(new TippSpielerXML("XML-Hansi", 1,11,111,0));
    listeTippSpielerXML.add(new TippSpielerXML("XML-Maria", 9,-22,8,1));
    listeTippSpielerXML.add(new TippSpielerXML("XML-Anton", 0,66,32100,2));
    listeTippSpielerXML.add(new TippSpielerXML("XML-Claudia", 2,139,6000,3));
  }
//---------------------------------------------------------------------------
  private void save(){
    try{
      File file = new File("TippSpieler.bin");
      ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
      oos.writeObject(listeTippSpieler); 
      oos.close();
    }
    catch(IOException ioe){
      ioe.printStackTrace();
    }
  }
//---------------------------------------------------------------------------
  private void saveXML(){
    try{
      File file = new File("TippSpieler.xml");
      XMLEncoder xEnc = new XMLEncoder(new FileOutputStream(file)); 
      xEnc.writeObject(listeTippSpielerXML);
      xEnc.close();
    }
    catch(IOException ioe){
      ioe.printStackTrace();
    }
  }
//---------------------------------------------------------------------------
  public static void main(String args[]){
    new WriteTippSpieler();
  }
}
```
Als letzes die Klasse zum Laden und Anzeigen der gespeicherten ArrayList

```
import java.util.*;
import java.io.*;
import java.beans.*;

class ReadTippSpieler{
List<TippSpieler> listeTippSpieler;
List<TippSpielerXML> listeTippSpielerXML;
//---------------------------------------------------------------------------
  public ReadTippSpieler(){
    read();
    printOut();
    System.out.println("------------------------------");
    readXML();
    printOutXML();
  }
//---------------------------------------------------------------------------
  private void read(){
    try{
      File file = new File("TippSpieler.bin");
      ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file)); 
      listeTippSpieler = (ArrayList<TippSpieler>)ois.readObject();
      ois.close();
    }
    catch(IOException ioe){
      ioe.printStackTrace();
    }
    catch(ClassNotFoundException cnfe){
      cnfe.printStackTrace();
    }
  }
//---------------------------------------------------------------------------
  private void readXML(){
    try{
      File file = new File("TippSpieler.xml");
      XMLDecoder xDec = new XMLDecoder(new FileInputStream(file)); 
      listeTippSpielerXML = (ArrayList<TippSpielerXML>)xDec.readObject();
      xDec.close();
    }
    catch(IOException ioe){
      ioe.printStackTrace();
    }
  }
//---------------------------------------------------------------------------
  private void printOut(){
    for(TippSpieler tippSpieler: listeTippSpieler)
      System.out.println(tippSpieler);
  }
//---------------------------------------------------------------------------
  private void printOutXML(){
    for(TippSpielerXML tippSpielerXML: listeTippSpielerXML)
      System.out.println(tippSpielerXML);
  }
//---------------------------------------------------------------------------
  public static void main(String args[]){
    new ReadTippSpieler();
  }
}
```

Wie die Warnmeldung
*ReadTippSpieler.java:21: warning: [unchecked] unchecked cast
found   : java.lang.Object
required: java.util.ArrayList<TippSpieler>
      listeTippSpieler = (ArrayList<TippSpieler>)ois.readObject();

ReadTippSpieler.java:36: warning: [unchecked] unchecked cast
found   : java.lang.Object
required: java.util.ArrayList<TippSpielerXML>
      listeTippSpielerXML = (ArrayList<TippSpielerXML>)xDec.readObject();*

wegzubekommen sind weiß ich auch nicht.

Viel Spaß

Grüss Max


----------



## Landei (11. Feb 2009)

> Wie die Warnmeldung
> ReadTippSpieler.java:21: warning: [unchecked] unchecked cast
> found : java.lang.Object
> required: java.util.ArrayList<TippSpieler>
> ...



@SuppressWarnings("unchecked")

...sollte in diesem Fall OK sein, dir bleibt ja keine andere Wahl, als zu casten, und du weißt ja, was du vorher reingeschrieben hast.


----------

