Caching inObjectOuputStream: bug or undocumented "feature"?!

Question

I'll give you the code in the end. The screen dump contains characters that is not allowed in to the editor window, so you'll have to run the code yourself to see the result.
This is what I did:
1. Create a LinkedList
2. Create an ObjectOutputStream connected to a ByteArrayOutputStream
3. Add an object to it
4. Serialize the LinkedList through ObjectOutputStream.writeObject()
5. Print the ByteArrayOutputStream the console.
6. Reset the ByteArrayOutputStream.
*. Do number 3 -> 6 a few times.
The result will be that what comes out in the ByteArrayOutputStream is cached (?) information. It does not matter how much you put into the list, you will allways get the first serialization out on the stream.
The second test I did was to serialize a clone of the list. Now things are going the way they should. All the added objects are sent to the stream.
I tested this using an ObjectInputStream as well, but this code takes less space and produces the behavior.
Now to my questions:
Is this really the way it should work? If it is why isn't it documented in the JavaDoc and why isn't there a more intelligent cache that can check if the object to be serialized has been changed?
The more I think of it the more worried I get. If someone has a big tree of som kind that the want to serialize, what happens if someone changes a small detail? Will that change go through? Not according to the test I just did. To clone every single object that go through the ObjectOutputStream more than once is not very good for performance...
Or does the cache only look at the "top" object?
Code:
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.LinkedList;
public class Test
 public static void main(String[] args)
  try
   ByteArrayOutputStream baOut = new ByteArrayOutputStream();
   ObjectOutputStream oOut = new ObjectOutputStream(baOut);
   LinkedList list = new LinkedList();
   for (int i = 0; i < 10; i++)
    list.add("Test" + i);
    System.out.println("Serializing: " + list);
    oOut.writeObject(list);
    System.out.println("Result: " + baOut.toString());
    baOut.reset();
   //Redoing the test but this time with list.clone()
   list = new LinkedList();
   for (int i = 0; i < 10; i++)
    list.add("Test" + i);
    System.out.println("Serializing: " + list);
    oOut.writeObject(list.clone());
    System.out.println("Result: " + baOut.toString());
    baOut.reset();
  catch (IOException e)
   e.printStackTrace();
/Lars

Answer 1

The ObjectOutputStream keeps track of whether or not
an object has been serialized, and if it has, any
further attemps to serialize the object will result in
a reference to the first occurence of the object in
the stream. This is to keep objects being serialized
multiple times unnecessarily.It is more than an optimization. This logic is required to avoid cycles during object graph serialization.