unterschiedliche Größe beim serialisieren eines Objektes!

[Lord_Aratorn]

class struct{
	char[] name = new char[30]; //30 byte
	short iD; // 2 byte
	short nummer;//2 byte

	char flagA; // 1byte
	char flagB; // 1byte
	char flagC; // 1byte
	char flagD; // 1byte
	
	public byte[] serialize() throws IOException {
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
		DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream);
		for (int i = 0; i < name.length; i++) {
			dataOutputStream.writeChar(name[i]);
		}
		dataOutputStream.writeShort(iD);
		dataOutputStream.writeShort(number);
		dataOutputStream.writeChar(flagA);
		dataOutputStream.writeChar(flagB);
		dataOutputStream.writeChar(flagC);
		dataOutputStream.writeChar(flagD);
		dataOutputStream.close();
		return byteArrayOutputStream.toByteArray();
	}
}

kann mir wer sagen, warum system.out.println(new struct().serialize.length) == 72 ist?
sollten es nicht eher
30+2+2+1+1+1+1 = 38 sein?

 

[kleiner_held]

char ist in Java ein Unicode Zeichen und das besteht aus 2 Byte

 

[Illuvatar]

Ein char hat 2 byte.

 

[Lord_Aratorn]

Super danke eine frage hätt ich noch.
Warum ist meine Objekt, wenn ich es so serialisiere 166 byte groß?

public byte[] serialize() throws IOException {
		try {
		    ByteArrayOutputStream bos = new ByteArrayOutputStream() ;
		    ObjectOutputStream out = new ObjectOutputStream(bos) ;
		    out.writeObject(this);
		    out.close();

		    System.out.println("bos: "+bos.toByteArray().length);//== 166
		    return bos.toByteArray();
			} catch (IOException e) {
				
			}
			return null;
	}

 

[SchonWiederFred]

Warum ist meine Objekt, wenn ich es so serialisiere 166 byte groß?

Bei mir sinds 180
Speicher den Inhalt doch mal in eine Datei und schau sie Dir mit nem Hex-Editor an:

Offenbar wird viel Metainformation gespeichert, z.B. der Name der Klasse und die Namen der Variablen.

 

[tuxedo]

Jepp, bei der Serialisierung kommt ne ganze Latte Overhead dazu. Erbt die Klasse dann noch von irgendwas anderem, wirds gleich nochmal viel mehr. Hab noch keinen Weg gefunden vorherzusagen wie groß eine Klasse wird, die von XYZ erbt und selbst XXX Bytes an primitiven Datentypen inne hat.

Bei meiner SIMON implementierung hab ich ein ähnliches Problem. Da ich mit NIO arbeite, kann ich nicht wirklich mit Streams arbeiten, weswegen ich die Objekte erst in ein byte[] (oder eben in meiner Varainte ein ByteBuffer) serialisiere, die größe ermittle, und dann in meinem Protokoll die größe des Objektes vorweg schicke.

Ein Objekt mehrmals serialsisiert, ergibt aber logischer weise immer die gleiche Größe.

- Alex

 

[ARadauer]

[qoute]Offenbar wird viel Metainformation gespeichert, z.B. der Name der Klasse und die Namen der Variablen.[/quote]
ich denk die uuid wird auch mitgegeben