# Serialisieren/deserialisieren



## Dany (3. Apr 2011)

Hallo,

Da ich noch Änfänger bin Java, kenn ich nicht alle Zusammenhänge die Klassen usw. zum funktionieren bringen.
Meine Frage bezieht sich auf das speichern, auf Festplatte, also wenn ein Programm beendet wird nicht gleich alle Daten wieder weg sind. Wenn ich z.B. ein Objekt habe das mir eine scanner-eingabe einliest, wie kann ich den code einfügen, der das abspeichert, muss ich zwei separate Dateien erstellen, oder kann ich den Code direkt in die scanner-datei einfügen?
Z.B. 

```
import java.util.Scanner;
import java.io.*;
  public class scanner1
  {
    
    public static void main(String[] args)
    {

            

      System.out.print("Bitte Name eingeben: ");
      
      Scanner eingabe = new Scanner(System.in);
      
      String name     = eingabe.nextLine();

      System.out.println("\nGuten Morgen "+name+"!");
      

    }
}
```

probiert hatte ich die Klassen, aber bin nicht sicher wie ich diese korrekt einfügen könnte?


```
FileOutputStream dat = new FileOutputStream("datei.dat");
  ObjectOutputStream out = new ObjectOutputStream(dat);
  
{
  FileInputStream dat = new FileInputStream("datei.dat");
  ObjectInputStream in = new ObjectInputStream(dat);
```

Vielen Dank
D.


----------



## Volvagia (3. Apr 2011)

Einfach reinschreiben, und out.writeObject() aufrufen. Vergiss aber nicht, dass du Exceptions per try/catch abfangen musst.


----------



## Dany (3. Apr 2011)

Das hab ich probiert, aber anscheinend gibts irgendwo einen Fehler?


```
import java.io.Serializable;
import java.util.Scanner;
import java.io.*;
  public class scanner3 implements Serializable
  {
    
    public static void main(String[] args) 
    {

            

      System.out.print("Bitte Name eingeben: ");
      
      Scanner eingabe = new Scanner(System.in);
      
      String name     = eingabe.nextLine();

      System.out.println("\nGuten Morgen "+name+"!");

try
{

 FileOutputStream dat = new FileOutputStream("datei.dat");
  ObjectOutputStream out = new ObjectOutputStream(dat);
  out.writeObject();
  out.close();
{
FileInputStream dat = new FileInputStream("datei.dat");
  ObjectInputStream in = new ObjectInputStream(dat);
  in.readObject();
  in.close();
      

}   
}
catch (Exception e)
{ 
  e.printStackTrace();
}
}
}
```

es ergibt die Fehlermeldung


```
C:\projects>javac scanner3.java
scanner3.java:25: writeObject(java.lang.Object) in java.io.ObjectOutputStream ca
nnot be applied to ()
  out.writeObject();
     ^
scanner3.java:28: dat is already defined in main(java.lang.String[])
  FileInputStream dat = new FileInputStream("datei.dat");
                  ^
2 errors
```

Vielen Dank 
D.


----------



## Volvagia (3. Apr 2011)

Du hast 2 unnötige geschwungene Klammern.
Es stimmt prinzipiell schon so. Ließ einfach die Fehlermeldung genau durch, du solltest von alleine drauf kommen. Er sagt dir auch die richtigen Zeilen.


----------



## Dany (3. Apr 2011)

Danke, hab das einwenig geändert bin aber nicht sicher ob das ganz stimmt, weil nach der eingabe eine Fehlermeldung kommt?

```
import java.io.Serializable;
import java.util.Scanner;
import java.io.*;
  public class scanner3 implements Serializable
  {
    
    public static void main(String[] args) 
    {

            

      System.out.print("Bitte Name eingeben: ");
      
      Scanner eingabe = new Scanner(System.in);
      
      String name     = eingabe.nextLine();

      System.out.println("\nGuten Morgen "+name+"!");

try
{

 FileOutputStream dat = new FileOutputStream("datei.dat");
  ObjectOutputStream out = new ObjectOutputStream(dat);
  out.writeObject(eingabe);
  out.close();
{
  FileInputStream dat1 = new FileInputStream("datei.dat");
  ObjectInputStream in = new ObjectInputStream(dat1);
  in.readObject();
  in.close();
      
}
}
 catch (Exception e)
{ 
  e.printStackTrace();
}
}
}
```

wo genau die geschweiften Klammern zuviel sind, erkenne ich nicht ganz?


```
C:\projects>java scanner3
Bitte Name eingeben:  Miss Tatcher

Guten Morgen  Miss Tatcher!
java.io.NotSerializableException: java.util.Scanner
        at java.io.ObjectOutputStream.writeObject0(Unknown Source)
        at java.io.ObjectOutputStream.writeObject(Unknown Source)
        at scanner3.main(scanner3.java:25)
```

ob ich da das Verziechnis ändern müsste, egentlich funktionierte es mit anderen datein im gleichen Verzeichnis schon?

Vielen Dank
D.


----------



## Volvagia (3. Apr 2011)

Das kommt daher, dass Scanner nicht serialisiert werden kann. Das ganze wird durch ein Interface (Serializable) bestimmt, wenn es nicht implementiert wird (Scanner, Socket, Thread etc.) kann es nicht serialisiert werden.
Du willst aber ja auch garnicht den Scanner (eingabe) serialisieren, sondern den String (name).

Die 2 unnötigen Klammer sind eine unter out.close und eine unter in.close.

Den letzten Satz verstehe ich leider nicht, ich bin mir nicht mal sicher ob das eine Frage ist.


----------



## Dany (3. Apr 2011)

Ja stimmt, das mit dem scanner geht ja nicht, habe es geändert, die Daten werden abgespeichert.
Die geschweiften Klammern, ja die waren zuviel.
Der letzte Satz ist irrelevant!
Müsste das ganze nur noch abrufen können, aber das ist eine andere Geschichte, ok ich könnte auch .txt benutzen, aber ok.

Vielen vielen Dank
Danny


----------



## Volvagia (3. Apr 2011)

Das geht dann genauso, nur eben anderstrum. 

```
name = (String)in.readObject();
```

Alternativ könntest du es noch so machen.

```
name = in.readObject().toString();
```

Funktioniert aber natürlich ausschließlich bei Strings.


Zum Abschluss könntest du noch versuchen, unter den catch einen finally-Block zu machen, und die Streams darin zu schließen. Dafür musst du die Variablen aber vor dem try definieren (nicht mit "=" zuweißen, sondern nur definieren), sonst sind sie im finally nicht mehr sichtbar. Das sollte immer gemacht werden, weil falls wärend dem Lesen eine Exception fliegt, wird das close einfach übersprungen und der Stream bleibt offen.


----------



## Dany (3. Apr 2011)

Ja, das probier ich...
Wieder etwas neues dazu gelernt!
Vielen Dank


----------



## Dany (4. Apr 2011)

Hallo,

Eigentlich funktionierts, aber beim abspeichern wenn ich die Datei danach öffne steht jewieils nur ein Eintrag drin, obwohl es aus komischen Zeichen besteht, die vorherigen Einträge stehen nicht drin. kann das sein das der finally block hier behilflich sein könnte?
Habe das mit dem finally probiert aber bin nicht sicher ob das so stimmt?


```
import java.io.Serializable;
import java.util.Scanner;
import java.io.*;
  public class scanner3 implements Serializable
  {
    
    public static void main(String[] args) 
    {

            

      System.out.print("Bitte Name eingeben: ");
      
      Scanner eingabe = new Scanner(System.in);
      
      String name     = eingabe.nextLine();

      System.out.println("\nGuten Morgen "+name+"!");

FileOutputStream dat;
ObjectOutputStream out;
FileInputStream dat1;
ObjectInputStream in;
try
{

  FileOutputStream dat = new FileOutputStream("datei.dat");
  ObjectOutputStream out = new ObjectOutputStream(dat);
  out.writeObject(name);
  out.close();

  FileInputStream dat1 = new FileInputStream("datei.dat");
  ObjectInputStream in = new ObjectInputStream(dat1);
  name = (String)in.readObject();
  in.close();
      

}
 catch (Exception e)
{ 
  e.printStackTrace();
}
 finally { in.close(); } { out.close(); }
}
}
```

Naja, sind halt basic Fragen, vielen Dank für die Antworten.
D.


----------



## Volvagia (4. Apr 2011)

Versuch mal das:

FileOutputStream dat = new FileOutputStream("datei.dat", true);
(Ungetestet)

Der finally-Tag verändert eigendlich nichts, ist nur eine Sicherheitsmaßnahme. Du hast aber mehrere Fehler drinnen.

1) Du kannst dat etc. nicht vor dem try und darin nochmal definieren.
2) close kann ebenfalls eine IOException schmeißen, die abgefangen werden muss.
3) Du hast beim finally wieder unnötige Klammern. Ist zwar kein Fehler, verursacht aber welche, wenn man nicht aufpasst.


----------



## Dany (4. Apr 2011)

Hallo,

Ja stimmt, mit "true" funktionierts er speichert alle Eingaben.
Bin aber nicht sicher wie ich den finally block schreiben könnte, wie er drin war funktionierte nicht.
Falls man die Eingaben auslesen möchte, ohen die Datei von Hand zu öffnen, müsste man eine separate Datei erstellen für das laden?


```
import java.io.Serializable;
import java.util.Scanner;
import java.io.*;
  public class scanner3 implements Serializable
  {
    
    public static void main(String[] args) 
    {

            

      System.out.print("Bitte Name eingeben: ");
      
      Scanner eingabe = new Scanner(System.in);
      
      String name     = eingabe.nextLine();

      System.out.println("\nGuten Morgen "+name+"!");

FileOutputStream dat;
ObjectOutputStream out;
FileInputStream dat1;
ObjectInputStream in;
try
{

  dat = new FileOutputStream("datei.dat", true);
  out = new ObjectOutputStream(dat);
  out.writeObject(name);
  out.close();

  dat1 = new FileInputStream("datei.dat");
  in = new ObjectInputStream(dat1);
  name = (String)in.readObject();
  in.close();
      

}
 catch (Exception e)
{ 
  e.printStackTrace();
}

}
}
```

Vielen Dank
D.


----------



## Volvagia (4. Apr 2011)

Natürlich nicht, die Datei wäre dann ja leer. Von dort kann er auch nichts lesen. 
Einfach finally darunter schreiben, die close's hineinverlegen und eine eventuell auftretende IOException abfangen.


----------



## Dany (5. Apr 2011)

Hallo,

Mit dem laden müsst ich noch ausprobieren, verstehs nicht ganz, wo man das platziert.
Den finally block hab ich drin, aber irgendwie kommen Fehlermeldungen?

```
}
 catch (Exception e)
{ 
  e.printStackTrace();
}
 finally 
{ 
      try{out.close();} catch (IOException e){} 
      try{in.close(); } catch (IOException e){}
}
}
}
```

Danke
D.


----------



## Volvagia (5. Apr 2011)

Zeig mal alles, ich kann hier auf die Schnelle nichts erkennen.


```
finally {
	try {
		if(out != null) {
			out.close();
		}
		if(in != null) {
			in.close();
		}
	} catch (IOException e) {}
}
```

Sonst fliegt dir eine NPE, falls beim Öffnen etwas schief gelaufen ist. Leg das Laden doch in eine eigene Methode, dann kannst dus prinzipiell von überall her aufrufen.


----------



## Dany (5. Apr 2011)

```
import java.io.Serializable;
import java.util.Scanner;
import java.io.*;
  public class scanner3 implements Serializable
  {
    
    public static void main(String[] args) 
    {

            

      System.out.print("Bitte Name eingeben: ");
      
      Scanner eingabe = new Scanner(System.in);
      
      String name     = eingabe.nextLine();

      System.out.println("\nGuten Morgen "+name+"!");

FileOutputStream dat;
ObjectOutputStream out;
FileInputStream dat1;
ObjectInputStream in;
try
{

  dat = new FileOutputStream("datei.dat", true);
  out = new ObjectOutputStream(dat);
  out.writeObject(name);
  

  dat1 = new FileInputStream("datei.dat");
  in = new ObjectInputStream(dat1);
  name = (String)in.readObject();
  
      

}
 catch (Exception e)
{ 
  e.printStackTrace();
}
 finally 
{ 
      try{out.close();} catch (IOException e){} 
      try{in.close(); } catch (IOException e){}
}
}
}
```


----------



## Volvagia (5. Apr 2011)

Klar, du musst out und in mit "= null"; intialisieren. Musst du bei jeder Klassenvariable machen. Ignoriere Fehler nicht so, die VM bzw. der Compiler versucht dir damit ja mitzuteilen, was du falsch gemacht hast, damit du den Fehler ausbessern kannst.


----------



## AmunRa (5. Apr 2011)

Ich glaub so müsste es jetzt gehen. 


```
import java.io.Serializable;
import java.util.Scanner;
import java.io.*;
  public class Test implements Serializable
  {
    
    public static void main(String[] args) 
    {
 
            
 
      System.out.print("Bitte Name eingeben: ");
      
      Scanner eingabe = new Scanner(System.in);
      
      String name     = eingabe.nextLine();
 
      System.out.println("\nGuten Morgen "+name+"!");
 
FileOutputStream dat = null;
ObjectOutputStream out =null;
FileInputStream dat1 = null;;
ObjectInputStream in = null;
try
{
 
  dat = new FileOutputStream("datei.dat", false);
  out = new ObjectOutputStream(dat);
  out.writeObject(name);
  
  name = "nix";
 
  dat1 = new FileInputStream("datei.dat");
  in = new ObjectInputStream(dat1);
  name = (String)in.readObject();
  
  System.out.println("Der geladene Name ist: " +name);
      
 
}
 catch (Exception e)
{ 
  e.printStackTrace();
}
 finally 
{ 
      try{if (out!=null){out.close();}} catch (IOException e){} 
      try{if (in!=null){in.close();} } catch (IOException e){}
}
}
}
```

Der FileOutput Stream darfübrigens nicht mit true initialisiert werden,da er sonst immer das erste gespeicherte Object lädt. Kannst ja mal ausprobieren wie sich der Unterschied auswirkt, wenn du das Programm mehrmals hintereinander ausführst (mit und ohne true)


----------



## Dany (5. Apr 2011)

Hallo,

Danke, sollte funktionieren, aber es kommen folgende Fehlermeldungen bei gleichem Quelltext...

```
C:\projects>javac scanner3.java
scanner3.java:48: variable out might not have been initialized
         try{if(out!=null) {out.close();}} catch (IOException e){}
                ^
scanner3.java:49: variable in might not have been initialized
         try{if(in!=null) {in.close();}} catch (IOException e){}
                ^
2 errors
```


```
import java.io.Serializable;
import java.util.Scanner;
import java.io.*;
  public class scanner3 implements Serializable
  {
    
    public static void main(String[] args) 
    {

            

      System.out.print("Bitte Name eingeben: ");
      
      Scanner eingabe = new Scanner(System.in);
      
      String name     = eingabe.nextLine();

      System.out.println("\nGuten Morgen "+name+"!");

FileOutputStream dat;
ObjectOutputStream out;
FileInputStream dat1;
ObjectInputStream in;
try
{

  dat = new FileOutputStream("datei.dat", false);
  out = new ObjectOutputStream(dat);
  out.writeObject(name);

  name = "nix";
  

  dat1 = new FileInputStream("datei.dat");
  in = new ObjectInputStream(dat1);
  name = (String)in.readObject();
  
  System.out.println("Der geladene Name ist: " +name);    

}
 catch (Exception e)
{ 
  e.printStackTrace();
}
 finally 
{ 
     
         try{if (out!=null){out.close();}} catch (IOException e){}
         try{if (in!=null){in.close();}} catch (IOException e){}
}
}
}
```

Vielen Dank für die Hilfe.
D.


----------



## SlaterB (5. Apr 2011)

nein, der Quelltext ist nicht gleich, zur Strafe solltest du das jetzt Zeichen für Zeichen vergleichen...,
oder fange einfacher bei Zeile 20 an, in deinem wie in AmunRa's Code-Block

edit: bis auf eingefügte Leerzeile 47 könntest du tatsächlich beide Codes in Texteditor einfügen und durch schnelles hin und her schalten vergleichen..


----------



## Dany (5. Apr 2011)

Moment, das stimmt schon es fehlte "=null" bei den variablen!

wieso ist das so mit true und false?

Vielen Dank
D.


----------



## AmunRa (5. Apr 2011)

```
dat = new FileOutputStream("datei.dat", true);
```

bedeutet, dass er alles was du in den Streamschreibst ans dateiende dran hängt.

```
dat = new FileOutputStream("datei.dat", false);
```

bedeutet, dass er alles was zum Zeitpunkt des erstellens des Streams löscht und nur den neuen Inhalt in die datei schreibt.

Wenn du also mit true arbeitest, und das erste mal den Namen Horst schreibst,
steht in der Datei

```
Horst
```
und diesen namen kannst du auslesen.
beim zeiten Durchlauf lässt du Franz schreiben,
daher hat die Datei den Inhalt

```
Horst
Franz
```
wenn du nun aber das erste Object aus der Datei liest ist das immer Horst


----------



## Dany (5. Apr 2011)

Ach so, vielen Dank für die Erklärung.
Müsste ohne false/true gleich funktionieren. Wie wärs wenn ich alle eingegeben Namen wie bei true, auch ausgeben möchte?
Danke
D.


----------



## Volvagia (5. Apr 2011)

Mehrmals (vor dem close natürlich) readObject() aufrufen, dann wird jedes mal das nächste Objekt ausgelesen.
Ich hab ihm das mit dem true gesagt, weil er recht am Anfang gesagt hat, dass natürlich nur der alte String drinnen steht.


----------



## Dany (5. Apr 2011)

Hi,

Ja müsste funktionieren, habs probiert aber bringt Exceptions?
Habt Ihr das so gedacht...

```
import java.io.Serializable;
import java.util.Scanner;
import java.io.*;
  public class scanner3 implements Serializable
  {
    
    public static void main(String[] args) 
    {

            

      System.out.print("Bitte Name eingeben: ");
      
      Scanner eingabe = new Scanner(System.in);
      
      String name     = eingabe.nextLine();

      System.out.println("\nGuten Morgen "+name+"!");

FileOutputStream dat=null;
ObjectOutputStream out=null;
FileInputStream dat1=null;
ObjectInputStream in=null;
try
{

  dat = new FileOutputStream("datei.dat", true);
  out = new ObjectOutputStream(dat);
  out.writeObject(name);

  
  name = "nix";

  dat1 = new FileInputStream("datei.dat");
  in = new ObjectInputStream(dat1);
  name = (String)in.readObject();
  name = (String)in.readObject();
  name = (String)in.readObject();

  System.out.println("Der geladene Name ist: " +name);    

}
 catch (Exception e)
{ 
  e.printStackTrace();
}
 finally 
{ 
     
         try{if (out!=null){out.close();}} catch (IOException e){}
         try{if (in!=null){in.close();}} catch (IOException e){}
}
}
}
```

hier der Fehler.

```
C:\projects>java scanner3
Bitte Name eingeben: Patrick

Guten Morgen Patrick!
java.io.StreamCorruptedException: invalid type code: AC
        at java.io.ObjectInputStream.readObject0(Unknown Source)
        at java.io.ObjectInputStream.readObject(Unknown Source)
        at scanner3.main(scanner3.java:37)
```



irgend etwas müsste man bei "in.readObject" ändern, bin nicht sicher was.

Vielen Dank
D.


----------



## Volvagia (5. Apr 2011)

Ich glaube, das kommt daher, dass du die Objekte mit unterschiedlichen OOSs geschrieben hast, und deshalb die Objektheader nicht mehr zusammenpassen.


----------



## Dany (5. Apr 2011)

Also das "dat1" und "dat" sind nicht gleich das stimmt, falls Ihr das meint. Bei gleichen Namen, gibt's eine Fehlermeldung wie im ersten message. Es liest einfach nur den ersten eingegebenen Namen aus, ansonsten funktionierts.


----------



## AmunRa (6. Apr 2011)

Du darfst nicht an das File appenden.

du kannst zwar mehrere Objecte in eine File serialisieren, und dann auch wieder deserialiesieren, aber nur solange du ein und den selben ObjectOutputStream benutzt.
Also so

```
String s = "Hallo";
		ObjectOutputStream objOut = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("test.ser")));
		objOut.writeObject(s);
		
		s= "mein";
		objOut.writeObject(s);
		s= "Computer";
		objOut.writeObject(s);
		objOut.close();
```

damit kannst du nun 3 Objekte auch wieder lesen.

wenn du aber mit append ein Object hinten anhängst und dies dann versuchst zu lesen, hast du mit jedem mal starten eine neue Instanz deines ObjectOutputStream erstellt und dann kannst du nur soviele Objekte lesen, wie mit der Instanz die in das File gechrieben hat serialisiert worden sind, alle anderen Objekte die ebenfalls in das File geschreiben wurden sind nicht mehr lesbar.


----------



## Dany (6. Apr 2011)

Ja, danke für die Beispiele, ist auch hilfreich und wissenswert, ist etwas neues das ich nicht einfach in code umschreiben kann, werde denn noch etwas googlen, wo vielleicht auch solche Beispiele erklärt werden. Bedeutet das jetzt, das man dass über den scanner nicht programmieren kann, oder muss ich im vorherigen code grössere Änderungen vornehmen? 
AmunRa, klingt als hätte dein Name auch etwas mit der Berechnung der Nachkommastellen von PI zu tun.  (off topic)
D.


----------



## Volvagia (6. Apr 2011)

Ich dachte, das ist was Ägyptisches.
Das hat nichts mir den Scanner zu tun. Du musst wohl alles lesen, und danach sämtliche veränderten Daten neu schreiben.


----------



## Dany (6. Apr 2011)

Ja Ägyptisch, hatt vielleicht auch mit Pyramiden zu tun, dort wird auch die Zahl PI benutzt und versucht die genaue Nachkommastelle herauszufinden.
Also müsste man irgendwo noch einen BufferedOutputStream einfügen, und der Input bleibt gleich?
Möchte es auch verstehen und umsetzen wie es erklärt ist, aber so einfach ist's auch nicht am anfang.


----------



## AmunRa (7. Apr 2011)

Nun das Problem ist, dass man immer nur eine Session in so ein File schreiben kann. 


Die Frage ist nun aber eher warum willst du etwas serialisieren? Einen String kann man z.B viel einfacher in ein File speichern. Wenn du uns nocheinmal erklären könntest was du speichern willst und warum dann könnte es einen einfacheren weg geben.


<off> AmunRa ist einfach die höchste ägyptische Gottheit des neuen Reiches. Und der Name war halt noch frei und hat mir gefallen.</off>


----------



## Dany (7. Apr 2011)

Das mit dem serialisieren wollte ich auf dem scanner ausprobieren, weil ich das vielleicht auf einer anderen Datei mit objekten genauso ausführen könnte. Eine Textdatei ein-/auslesen (system.in) wäre in diesem Fall womöglich besser gewesen, aber ich wollte das mit der serialisierung verstehen.
Im Beispiel Scanner, wollte ich einzelne Namen eingeben, die bei jedem Start, weiter in eine Datei gespeichert werden, und auch jedesmal die Liste der Namen ausgibt. Vielleicht müsste man eine Anweisung zum löschen noch einfügen, aber ich belasses mal beim ein-/auslesen.

[off] Gabs da nicht noch eine Gottheit, die noch grösser war? Also kennst du dich mit Ägyptologie aus, irgendwie interessant? [/off]

D.


----------



## AmunRa (7. Apr 2011)

Am besten für sowas ist du nimmst eine ArrayList und serialisierst diese. 
Dann musst du nur ein Object serialisieren (die Liste) und kannst trotzdem beliebig viele Strings speichern.
Wenn du einen neuen Namen hinzufügen möchtest, musst du einfach den namen in die Liste schreiben und die Liste neu speichern.


```
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Scanner;

public class Test {

	public static void main(String[] args) {

		
		
		ArrayList<String> nameList ;
		FileInputStream dat1 = null;
		ObjectInputStream in = null;
		
		try{
		dat1 = new FileInputStream("datei.dat");
		in = new ObjectInputStream(dat1);
		nameList = (ArrayList<String>) in.readObject();
		}catch(Exception e){
			nameList= new ArrayList<String>();
		}finally{
			if (in!=null)try{in.close();}catch(Exception e2){};
		}
		System.out.println("Bereits gespeicherte Namen:");
		for (String s :nameList){
			System.out.println(s);
		}
		FileOutputStream dat = null;
		ObjectOutputStream out = null;
		
		System.out.print("Bitte Name eingeben: ");

		Scanner eingabe = new Scanner(System.in);

		String name = eingabe.nextLine();
		System.out.println("\nGuten Morgen " + name + "!");
		nameList.add(name);
		
		try {

			dat = new FileOutputStream("datei.dat", false);
			out = new ObjectOutputStream(dat);
			out.writeObject(nameList);

			

			
			

		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (out != null) {
					out.close();
				}
			} catch (IOException e) {
			}
			
		}

	}
}
```


<off>
Ich hab mich nicht sehr mit Ägypten beschäfftig nur das was man mal in der Schule gelernt hat. 
So wie ich weiß hats eben in der Zeit vor dem Neuen Reich andre Götter gegeben z.B den Amun und den Rah bzw Re und aus denen is dann eben die höchste Gottheit Amunra bzw amunre geworden.
Aber wenn dus genauer haben möchtest musst du irgendwo selber nachlesen. 
</off>


----------



## Dany (7. Apr 2011)

Hey,

Vielen Dank für den Beispielcode, oben hast du bei import verschiedene klassen drin, wäre es auch mit Serializable, anstatt mit File-/Input-/OutputStream gut gewesen?

habs probiert aber es kommt folgende Meldung...

Note: scanner4.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

C:\projects>javac -Xlint scanner4.java
scanner4.java:23: warning: [unchecked] unchecked cast
found   : java.lang.Object
required: java.util.ArrayList<java.lang.String>
        nameList = (ArrayList<String>) in.readObject();

Ja gut als Beispiel find ichs gut, hoffe das es mir bei weiteren serialisierungen hilft. 

Vielen Dank
D.

[off] Ja da gabs mehrere, AmunRa sicherlich sehr bekannt, ansonsten find ich die Rätsel rundum das Giza-plateau interessant, aber gelesen hab ich auch noch nicht viel. [/off]
                                                    ^


----------



## Volvagia (7. Apr 2011)

Ich vermute, du hast irgend etwas anderes in die Datei geschrieben, und versuchst es jetzt in eine Liste zu casten.


----------



## AmunRa (7. Apr 2011)

Die Warnung kommt, da du ein Object liest und dies in eine ArrayList castest. Der kompiler kann nicht überprüfen, dass das Object das er aus dem File liest auch wirklich eine ArrayList ist. Daher kommt die Warning. Das kannst du aber ruhig ignorieren. 


Das interface Serializable brauchst du blos wenn du ein Object deiner Eigenen Klasse Serialisieren möchtest.

z.B. Wenn du eine Klasse Auto erstellst und dann ein Object der Klasse Auto serialisieren willst dann muss die Klasse Auto Serializable implementieren. ansonsten ist dies nicht nötig. 
Deine Beispielklasse scanner3 hätte auch ohne den Zusatz implements Serializable funktioniert.


----------



## Dany (8. Apr 2011)

Ja, danke, funktioniert sehr gut. Das mit dem import java.Serializable, und Auto Objekte, meintest du vielleicht dass es nötig wäre wenn man eine package hat, über die zugegriffen wird?

Danke
D.


----------

