Java Serialization Behavior

Question

I'm going through serialization and I can't understand the following:

I don't understand why the output of this code is:

import java.io.*;

public class InnerOuterTest {
    public static ObjectOutputStream out;
    public static ObjectInputStream in;

    static {
        try {
            out = new ObjectOutputStream(new FileOutputStream("save.ser"));
            in = new ObjectInputStream(new FileInputStream("save.ser"));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        try {
            ShouldForgive f = new ShouldForgive();
            f.x = 5;
            write(f);
            ShouldForgive g = read();
            System.out.println(g.x);
            f.x = 0;
            g.x=8;
            write(f);
            ShouldForgive v = read();
            System.out.println("is "+v.x);
        } finally {
            out.close();
            in.close();
        }
    }

    private static void write(ShouldForgive f) throws IOException {
        out.writeObject(f);
    }

    public static ShouldForgive read() throws ClassNotFoundException, IOException {
        return (ShouldForgive) in.readObject();
    }
}

class ShouldForgive implements Serializable {
    int x = -1;
}

Is

5
8

And not

5
0

I tried f == g which returns false and if I reset the input stream. I found out that if I implement readObject it is only called once... I don't understand this behavior. (Why is the object only read once?)

I get the feeling that serialization only happens once... How is the object tracked? Even if I implement readObject and writeObject without actually reading or writing from the file I still get 8

user207421 · Accepted Answer · 2014-05-14 09:44:22Z

2

If you call out.reset() after the first write, you will get the behaviour you are expecting, or if you use writeUnshared() instead of writeObject(). Objects that have already been written to the stream are not rewritten; instead a 'handle' to the previously written object is written. See the Javadoc for details.

edited May 14, 2014 at 9:44

answered Jun 30, 2012 at 1:57

user207421

312k45 gold badges324 silver badges494 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Kumar Vivek Mitra · Accepted Answer · 2012-06-29 15:56:18Z

-1

OK...I think i got it...

During serialization, its NOT the object which is serialized, but its Instance variable... as extracted and stored. For an object its instance variable is everything...
So during de-serialization, the same instance variables are inflated back, and using those instance variable value, an Another Identical object is created on the heap..
If you check the hashcode of both these objects, they will be different.

Thats causing the above behaviour mentioned by you.

Either follow this sequence

f.x = 0;
g.x=8;

or this

g.x=8;       
f.x = 0;

Still the result will be 8, cause its now a completely different object on the heap with different instance variables.

Edited part

The below code will print f as 5..... for both the sysout

public static void main(String[] args) throws IOException, ClassNotFoundException {
        try {
            ShouldForgive f = new ShouldForgive();
            f.x = 5;
            write(f);
            ShouldForgive g = read();
            System.out.println(g.x);

            f.x=0;
            write(f);
            ShouldForgive v = read();
            System.out.println("is "+v.x);
        } finally {
            out.close();
            in.close();
        }
    }

edited Jun 29, 2012 at 15:56

answered Jun 29, 2012 at 15:48

Kumar Vivek Mitra

33.5k6 gold badges51 silver badges75 bronze badges

3 Comments

kosa Over a year ago

Not quiet clear. If they are two different objects, how write "f" writing value "8"?

user207421 Over a year ago

The hashcodes are quite likely to be the same if the object is well written.

user207421 Over a year ago

Not the correct answer. And the hashcodes can still be the same if the objects are different instances.

Collectives™ on Stack Overflow

Java Serialization Behavior

2 Answers 2

Comments

3 Comments

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

3 Comments

Related