Should a serialized Java object always be represented by the same sequence of bytes each time is it serialized?

Question

For, example if the object instance was serialized (resulting in 'byte[] bs1') then serialized again (resulting in 'byte[] bs2'), should 'bs1' and 'bs2' be the same length and contain the same bytes? If not, why not?

To avoid ambiguity, I should say that the two serializations of the same object (not two 'identical' objects - the same instance), happened within milliseconds of each other, in the same thread, on the same JVM - one before the (mutable) object was passed to a method, one after.

Note, that the object is not even being serialized, deserialized, and then re-serialized - it is just being serialized twice. Also, there is nothing at all 'clever' about the object's class; it is just a simple, aggregate POJO.

I'm using the serialized bytes as an ad hoc test to detect if the object has been changed inside the method. However, I seem to be seeing examples where the object has clearly not changed its state - yet one byte[] is different from the other.

I was assuming - and it was just an assumption - that they would be the same. Is there some reason they might not be?

Addendum:

Also, apologies for no example code to illustrate the point. Currently this is a small piece of code embedded in a large system. I'll try and extract a smaller, runnable demonstration, if necessary. I wondered if there was a basic issue with my assumption though, and therefore if anyone could explain why the assumption is wrong.

Answer 1

It might not always be the exact same sequence of bytes that is produced through serialization. For example, the order in which a Set serializes its elements is not guaranteed to be constant, even if we're talking about a single instance.