Object serialization and order

[leo donahue]

I was just reading in HFJ about object serialization. When we serialize an ojbect with an instance variable that is an object ref, HFJ says that the entire object graph will get serialized. But my question is: "In what order are instance variables serialized"? Does it follow the order in which they appear in the serializing class?

[Maulin Vasavada]

Hi leo
Why would that order matter to us? As far as we get the same object that we wrote its fine I guess.
Thanks
Maulin

[Tim West]

It's an interesting academic question...at least, I think so. It was posted somewhere here a while back and got no answer...I can't find anything on Google and I have a few spare minutes, so let's find out:

import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Serializable;
public class SerialTest {
    public static void main(String[] args) {
        Serial s = new Serial();
        Serial2 s2 = new Serial2();
        Serial3 s3 = new Serial3();
        try {
            ObjectOutputStream out = new ObjectOutputStream(new HexOutputStream(System.out));
            out.writeObject(s);
            out.writeObject(s2);
            out.writeObject(s3);
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }
}
// Test serialisation of objects of same type/scope
class Serial implements Serializable {
    public String c = "ccccc";
    public String a = "aaaaa";
    public String b = "bbbbb";
}
// Serial2 and Serial3 test objects of same type and different scope
class Serial2 implements Serializable {
    private String c = "ccccccc";
    protected String b = "bbbbbbb";
    public String a = "aaaaaaa";
}
class Serial3 implements Serializable {
    public String    c = "cccccccccc";
    protected String b = "bbbbbbbbbb";
    private String   a = "aaaaaaaaaa";
}

(See bottom of post for code to HexOutputStream.)
OK, so the output isn't going to be exactly legible, but:

AC ED 00 05 73 72 00 06 53 65 72 69 61 6C 06 4D 8B 98 43 07
 AF B5 02 00 03 4C 00 01 61 74 00 12 4C 6A 61 76 61 2F 6C 61
 6E 67 2F 53 74 72 69 6E 67 3B 4C 00 01 62 71 00 7E 00 01 4C
 00 01 63 71 00 7E 00 01 78 70 74 00 05 [B]61 61 61 61 61[/B] 74 00
 05 [B]62 62 62 62 62[/B] 74 00 05 [B]63 63 63 63 63[/B] 73 72 00 07 53 65
 72 69 61 6C 32 FE FC 52 9F D4 3D 08 8E 02 00 03 4C 00 01 61
 71 00 7E 00 01 4C 00 01 62 71 00 7E 00 01 4C 00 01 63 71 00
 7E 00 01 78 70 74 00 07 [B]61 61 61 61 61 61 61[/B] 74 00 07 [B]62 62
 62 62 62 62 62[/B] 74 00 07 [B]63 63 63 63 63 63 63[/B] 73 72 00 07 53
 65 72 69 61 6C 33 00 69 A8 22 7C 24 CF 3B 02 00 03 4C 00 01
 61 71 00 7E 00 01 4C 00 01 62 71 00 7E 00 01 4C 00 01 63 71
 00 7E 00 01 78 70 74 00 0A [B]61 61 61 61 61 61 61 61 61 61[/B] 74
 00 0A [B]62 62 62 62 62 62 62 62 62 62[/B] 74 00 0A [B]63 63 63 63 63
 63 63 63 63 63[/B]

Despite my dodgy HexOutputStream, things seem to work - the "magic number" that starts all serialisation stream (AC ED) is present at the start of the output and the serialisation format version number (00 05) is the current one for my JRE.
OK, so assuming it all works the important things are 61, 62, 63 (chars 'a', 'b', 'c'). In each case, it seems they come out in that order 'a', 'b', 'c'.
Conclusion: variables of the same type are serialised in alphabetical order, regardless of their scope.
Question: do all variables behave like this, regardless of their type? I'd check that out, but it'd mean decoding the serialisation hex dump pretty thoroughly because other types aren't nearly as easy to find as Strings. (Maybe longs containing Long.MIN_VALUE would be easy to find?)
This is hardly scientific, but it's a start. Any advances?

--Tim
For reference, the HexOutputStream in its dodgy glory:

// Warning - does this work OK? Really?
class HexOutputStream extends FilterOutputStream {
    
    PrintWriter out;
    int count = 0;
    
    HexOutputStream(OutputStream o) {
        super(o);
        out = new PrintWriter(o);
    }
    
    public void write(int b) {
        count++;
        out.write(formatInt(b));
        if (count % 20 == 0) 
            out.write("\n");
        out.flush();
    }
    
    public void write(byte[] b) {
        for (int i = 0; i < b.length; i++)
            write(b[i]);
    }
    
    public void write(byte[] b, int off, int len) {
        for (int i = off; i < off + len; i++) 
            write(b[i]);
    }
    
    private static String formatInt(int a) {
        int b = (a + 256) % 256; // Why was I getting negative values? I don't know!
                                 // This seems to work though.
        return " " + digits[b / 16] + digits[b % 16];
    }
    
    private static char[] digits = {'0', '1', '2', '3', '4', '5', '6', '7',
                                    '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
}

[ April 27, 2004: Message edited by: Tim West ]
[ April 28, 2004: Message edited by: Tim West ]