Ist es möglich eine LinkedList zu serialisieren? Nlw. sollte das doch möglich sein, da ich von der LinkedList ein Objekt anlege und ich dieses auch serialisieren kann. Ich habe es versucht, aber ich bekomme die Fehlermeldung java.io.NotSerializableException...
Die Liste zu serialisieren ist sicher möglich (auch wenn ichs noch nie ausprobiert habe), immerhin implementiert sie ja extra das "Serializable"-Interface.
Aber was ist mit den Elementen, die in der Liste drinstehen? Die werden auch serialisiert, und müssen deshalb serialisierbar sein... (was steht denn bei dir in der Liste?)
Ich habe auch bei jeder Klasse, dessen Objekte in die Liste eingefügt werden und somit auch serialisiert werden, "implements Serializable" geschrieben. Trotzdem kommt die Fehlermeldung. Hier ist meine Personenverwaltungsklasse, wo die Personen serialisiert werden sollen.
Code:
import java.util.LinkedList;
import java.util.ListIterator;
import java.io.*;
public class Personenverwaltung implements Serializable
{
LinkedList verw=new LinkedList();
ListIterator it = verw.listIterator();
Personenverwaltung() throws Exception {
}
public void addPerson(Person person) throws Exception {
verw.addLast(person);
}
public void speicherePersonen(Personenverwaltung verwaltung) throws FileNotFoundException, IOException {
ObjectOutputStream objOut = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("test.ser")));
objOut.writeObject(verwaltung);
objOut.close();
verw.clear();
}
public void ladePersonen() throws FileNotFoundException, IOException, ClassNotFoundException {
ObjectInputStream objIn = new ObjectInputStream(new BufferedInputStream(new FileInputStream("test.ser")));
Personenverwaltung verw=(Personenverwaltung) objIn.readObject();
objIn.close();
}....
Dies ist eine Personenklasse unter vielen:
Code:
import java.io.Serializable;
public class Professor
extends Person implements Serializable
{
private String Fachbereich;
private String Fachgruppe;
private String Personalnummer;
private String Personennummer;
private Personenverwaltung personenverwaltung;
public Professor(String name, String vorname, String Personennummer, String fachbereich, String fachgruppe, String personalnummer) {
setFachbereich(fachbereich);
setFachgruppe(fachgruppe);
setPersonalnummer(personalnummer);
setPersonennummer(Personennummer);
setName(name);
setVorname(vorname);
}
public String getFachbereich()
{
return this.Fachbereich;
}...
und hier ist die main()-Methode:
Code:
import java.io.*;
public class Start {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader stdin = new BufferedReader(isr);
Personenverwaltung verw=new Personenverwaltung();
Start() throws Exception {
mainmenu();
}
public void mainmenu() throws Exception
{
System.out.println("Willkommen beim Personenverwaltungssystem\n");
System.out.println("Bitte wählen Sie eine Funktion aus:\n");
System.out.println("(1) neue Person anlegen");
System.out.println("(2) bestehende Person löschen");
System.out.println("(3) Personen auflisten");
System.out.println("(4) Person suchen");
System.out.println("(5) System beenden");
System.out.println("\nNummer eingeben:");
String mainNummer=stdin.readLine();
int befehl=Integer.parseInt(mainNummer);
switch(befehl)
{
case 1: addPersonMenu(); break;
case 2: deletePer(); break;
case 3: viewPer(); break;
case 4: searchPer(); break;
case 5: shutDown(); break;
default: System.out.println("Auswahl existiert nicht!\nBitte erneut versuchen\n\n\n"); mainmenu(); break;
}
}
public void viewPer() throws Exception {
System.out.println("---------------------------------------------");
System.out.println("Personen anzeigen");
System.out.println("---------------------------------------------");
verw.viewPerson();
System.out.println("Sie werden zum Hauptmenü weitergeleitet.\n\n");
mainmenu();
}
/*public void deletePer() throws Exception
{
System.out.println("---------------------------------------------");
System.out.println("Bestehende Person löschen");
System.out.println("---------------------------------------------");
System.out.println("\nName eingeben:");
String Name=stdin.readLine();
System.out.println("Vorname eingeben:");
String Vorname=stdin.readLine();
verw.removePerson(Name,Vorname);
System.out.println("Möchten Sie eine weitere Person löschen? (y/n)");
String antwort=stdin.readLine();
if(antwort.equals("y")) {
deletePer();
}
else if(antwort.equals("n")) {
System.out.println("Sie werden zum Hauptmenü weitergeleitet.\n\n");
mainmenu();
}
else {
System.out.println("Ihr Eingabe ist nicht korrekt! Bitte erneut versuchen");
}
} */
public void shutDown() throws FileNotFoundException, IOException
{
System.out.println("---------------------------------------------");
System.out.println("System beenden");
System.out.println("---------------------------------------------");
verw.speicherePersonen(verw);
System.out.println("Daten werden gespeichert...\nProgramm wird beendet");
}
...
Die Methode shutDown() soll das Programm beenden bzw. die Daten serialisieren.
der ListIterator ist nicht serialisierbar, was auch unlogisch wäre... warum speicherst du ihn überhaupt in der verwaltung ?
noch was zur Programmlogik:
warum speichert ein Professor nochmals eine Instanz von Personalverwaltung... das führt zu einer verkettung. Personalverwaltung hält Instanzen von Personen, die wiederum eine Instanz der Personalverwaltung habe.... das wird dir die serialisierung um die Ohren hauen !
warum speichert ein Professor nochmals eine Instanz von Personalverwaltung... das führt zu einer verkettung. Personalverwaltung hält Instanzen von Personen, die wiederum eine Instanz der Personalverwaltung habe.... das wird dir die serialisierung um die Ohren hauen !
ne wird es nicht, da es ein object nur einmal gibt und dann nur die adresse zum object immer angegeben wird. also sowas wie ne endlosschleife wird das nicht.
aber beim laden machst du was komisches. du lädst aus der datei die personenverwaltung in die variable verz, einer lokalen variable und dann machst du nix weiter mit dieser variable, dann is klar das du die einträge hinter nicht mehr hast.
aber beim laden machst du was komisches. du lädst aus der datei die personenverwaltung in die variable verz, einer lokalen variable und dann machst du nix weiter mit dieser variable, dann is klar das du die einträge hinter nicht mehr hast.
Du hast recht, hatte die Klassen in Fujaba falsch assoziiert. Habe das nun entfernt. Dennoch ist das Problem nach wie vor vorhanden. Ich kann mich an früher erinnern, dass ich die LinkedList serialisieren konnte, aber kann mich an die Ausführung kaum noch erinnern. Geht das denn wirklich nicht?
aber beim laden machst du was komisches. du lädst aus der datei die personenverwaltung in die variable verz, einer lokalen variable und dann machst du nix weiter mit dieser variable, dann is klar das du die einträge hinter nicht mehr hast.
Du hast recht, hatte die Klassen in Fujaba falsch assoziiert. Habe das nun entfernt. Dennoch ist das Problem nach wie vor vorhanden. Ich kann mich an früher erinnern, dass ich die LinkedList serialisieren konnte, aber kann mich an die Ausführung kaum noch erinnern. Geht das denn wirklich nicht?
Exception in thread "main" java.io.NotSerializableException: java.util.LinkedList$ListItr
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1054)
at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1332)
at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1304)
at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1247)
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1052)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:278)
at Personenverwaltung.speicherePersonen(Personenverwaltung.java:18)
at Start.shutDown(Start.java:78)
at Start.mainmenu(Start.java:33)
at Start.addPersonMenu(Start.java:114)
at Start.addAdmin(Start.java:137)
at Start.addPersonMenu(Start.java:111)
at Start.mainmenu(Start.java:29)
at Start.<init>(Start.java:10)
at Start.main(Start.java:194)
Das habe ich schon! Manche wissen halt mehr als andere, deswegen habe ich diese Antwort ignoriert, in der Hoffnung, dass mir jemand sagt, wie ich das machen muss. Außerderm habe ich es schonmal geschafftt!
Das habe ich schon! Manche wissen halt mehr als andere, deswegen habe ich diese Antwort ignoriert, in der Hoffnung, dass mir jemand sagt, wie ich das machen muss. Außerderm habe ich es schonmal geschafftt!
Brauchst nicht gleich sarkastisch zu werden. Ich habe das nicht böse gemeint. Ich zweifel nicht an deine Erfahrungen und Können als Programmierer, ich wollte halt nur ein paar Meinungen dazu hören.
Nun gut, eine Frage habe ich noch. Wie schaffe ich es dann mehrere Objekte unterschiedlicher Klassen zu serialisieren? Ich habe mir gedacht, alles in einer Liste packen und die Liste serialisieren und damit hat sich die Geschichte. Ist doch nicht so einfach wie ich mir dachte. Habe ihr einen alternativen Vorschlag?
Den Iterator benötige ich um die Liste zu durchlaufen, da ich eine serchPerson(String Name) habe, die die Liste durchläuft und die passende Person mit den Namen findet.
Ok, tut mir echt leid Jungs. Habe den Wald vor lauter Bäumen nicht gesehen. Habe nun den Iterator für das Serialisieren gesperrt und nun klappt alles wunderbar! Danke für eure Tipps und die Geduld.
Warum sollte der Iterator nicht persistent sein?
Den Iterator benötige ich um die Liste zu durchlaufen, da ich eine serchPerson(String Name) habe, die die Liste durchläuft und die passende Person mit den Namen findet.
wenn du nur einen Iterator hast und immer auf diesem arbeitest wirst du nicht glücklich, da er immer auf der gefundenen Position bleibt, d.h. er resettet sich nicht und sucht somit nicht immer vom Anfang der Liste. D.h. z.b. ist er mal ans Ende gelangt kannst du gar nicht mehr suchen.
Beim ListIterator kannst du zwar wieder von hand den Iterator nach vorne bewegen, aber der Normalfall ist, dass für jede suche ein neuer Iterator erstellt wird. Der Iterator gibt ja nicht neue Informationen wieder, sondern gibt dir nur eine Möglichkeit die Liste zu durchlaufen.
public class Personenverwaltung implements Serializable
{
LinkedList verw=new LinkedList();
ListIterator it = verw.listIterator();
// völliger unsinn das hier aufzurufen :-)
Personenverwaltung() throws Exception {
}
nochmal was fundamentales
ein Iterator hat keinerlei Lebensberechtigung ausserhalb der Iteration für die er eingesetzt wird; nach jeder Modifikation der Liste ausserhalb des Iterators wird er "ungültig"
du gewinnst NICHTS und machst dir das Leben nur schwerer wenn du ihn als Member-Variable speicherst
aber wenn du das unbedingt willst: schreib doch das Wörtchen "transient" davor
nicht allzuböse nehmen :wink: 
