Zitat von java-girl

AFAIK müssen Objekte, die du mit einem ObjectStream schreibt, das Interface Serializable implementieren. Vermutlich tut das dein Objekt nicht bzw. schätze ich dass nur das Vector-Object rausgeschrieben wird, und die anderen Objekte einfach generell nicht.

Wenn eine Instanz einer Klasse verwendet wird, die Serializable nicht implementiert, wird eine NotSerializableException geworfen.

Zitat von java-girl

Deswegen rate ich dir ausdrücklich davon ab, deine Daten auf diese Art und Weise zu speichern. Für so etwas entwirft man sich immer einen eigenen Dokumenttyp für den man dann einen Parser schreibt. Oder einfach ausgedrückt: schreibs in eine Textdatei.

Unsinn. Serialisierung ist - wenn man nur Java verwendet - ein tolles Feature, warum sollte man sie nicht verwenden? Wenn die Daten beim Einlesen unbrauchbar sind oder nicht zu der Java-Klasse passen, bekommst du eine entsprechende Exception. Sich ein Dokumentenformat ausdenken und dafür Ein-/Ausgabemodule schreiben, das ist nur unnötiger Bloat und eine Fehlerquelle.

Zitat von java-girl

Mir wurde von jemandem davon abgeraten, dessen Meinung ich sehr schätze.

Überzeugendes Argument.

Zitat von java-girl

Außerdem muss man ja bei einem Vector den Aufwand betreiben, jedes enthaltene Objekt einzeln rauszuschreiben.

Blödsinn.

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Vector;


public class VectorSerialization {
	public static void main(String[] args) throws Exception {
		Vector<String> vector1 = new Vector<String>();
		vector1.add("a");
		vector1.add("b");
		vector1.add("c");

		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("file"));
		out.writeObject(vector1);
		out.close();

		ObjectInputStream in = new ObjectInputStream(new FileInputStream("file"));		
		@SuppressWarnings("unchecked")
		Vector<String> vector2 = (Vector<String>)in.readObject();
		for(String string : vector2) {
			System.out.println(string);
		}
	}
}

Ausgabe:

a
b
c

Zitat von Nicholas1991

Denn der Vektor enthält relativ VIELE verschiedene Informationen

D.h. da ist einmal ein Integer drin, einmal ein String, einmal ein Date? Das ist nicht schön. Da fehlt nämlich jegliche Typinformation.

Ein Programmierfehler könnte dazu führen, dass ein völlig falsches Objekt in den Vektor eingefügt wird; dieses Problem wird vom Compiler nie erkannt und tritt daher erst zur Laufzeit zu Tage. Es hat vielleicht ganz andere Auswirkungen als man vermuten würde und ist die Ursache ist daher schwer zu lokalisieren.

Lösung: Strukturiere die Daten.

Variante 1: Nehmen wir an, du hast Integers, Strings und Dates, die du jetzt alle in einem Vector speicherst. Zerteile diesen Vector in drei Vectors, wobei jeder Vector nur Elemente eines einzigen Typs speichert. Weiters brauchst du eine Klasse, welche nichts anderes macht als eben diese drei Vectors als Instanzvariablen zu haben:

public class MyData {
    private Vector<String> stringVector;
    private Vector<Integer> integerVector;
    private Vector<Date> dateVector;
}

Da musst du dir dann noch überlegen, wie der Zugriff auf diese drei Variablen funktionieren soll (in meinem Vorschlag sind sie ja private, damit von außen nicht direkt auf den Zustand eines Objekts vom Typ MyData zugegriffen werden kann).

Wenn du das Problem so angehst, hast du drei Listen in denen wirklich nur Objekte der gewünschen Typen enthalten sind. Alles andere führt zu Compilerfehlern (solange du nicht sinnlos herumcastest).

Variante 2: Du hast Informationen unterschiedlicher Typen, für die es einen gemeinsamen Oberbegriff gibt. In diesem Fall kannst du eine abstrakte Klasse (oder ein Interface) als Repräsentation dieses Oberbegriffs definieren und Klassen für speziellere Informationen davon ableiten. In deinem Vector speicherst du dann Instanzen der abstrakten Klasse (bzw. des Interfaces).

Nehmen wir an, wir wollen Informationen speichern, wie auf einen bestimmten Dienst zugegriffen werden kann. Da gibt es zum Beispiel die Möglichkeit des Zugriffs über TCP, da brauchst du IP-Adresse/Hostname und Port; andererseits gibt es die Möglichkeit des Zugriffs über UDP, auch mit IP-Adresse/Hostname und Port. Diese Daten wollen wir alle in einem Vector speichern.

Dazu definieren wir einmal eine abstrakte Klasse:

public abstract class AccessInformation {
}

und dann zwei Klassen, eine für TCP-Informationen und eine für UDP-Informationen:

public class TCPAccessInformation extends AccessInformation {
    private InetAddress host;
    private int port;
}

public class UDPAccessInformation extends AccessInformation {
    private InetAddress host;
    private int port;
}

Der Vector, in dem wir die Daten speichern, ist dann ein Vector<AccessInformation>. In diesem Vector können wir Instanzen der Typen TCPAccessInformation sowie UDPAccessInformation speichern, sonst nichts.

Der Unterschied zwischen TCPAccessInformation und UDPAccessInformation ist hier nicht wirklich gravierend. Das ganze ist aber erweiterbar; wenn beispielsweise der Zugriff auf den Dienst auch über ein Webservice möglich ist, könnte man eine weitere Klasse von AccessInformation ableiten, welche die entsprechenden Zugriffsdaten (eine URL einer WSDL) kapselt. Auch diese kann man dann in unserem Vector speichern.

So, jetzt hab ich aber genug geschwafelt. Ich hoffe, ich habe endgültig alle Klarheiten beseitigt.