A problem using serialization and/or not overwritten variables

Question

I have a problem while writing objects in ObjectOutputStream :
Here is a simplified version of the program :
class InDData implements serializable
     private Vector shapeVector = new Vector ();
     public InDData (Vector shapeV)
          this.shapeVector = shapeV;
     public int getShapeVectorSize ()
          return (this.shapeVector.size());
class InDShape implements serializable
     private Vector points = new Vector();
// client side
ObjectOutputStream p = new ObjectOutputStream(new BufferedOutputStream (connection.getOutputStream()));
InDData objectData = (InDData) vectorObjectsToBeSentThroughNetwork.remove(0);
System.out.println(objectData.getShapeVectorSize(); //print 1
p.writeObject(objectData);
p.flush();
//server side
ObjectInputStream in = new ObjectInputStream(new BufferedInputStream (connection.getInputStream()));
Object oTemp = in.readObject();
if (oTemp instanceof InDData)
     InDData objectData2 = (InDData) oTemp;
     System.out.println(objectData2.getShapeVectorSize(); //print 2
Some explanations before the main dish :)
I am writing a client that allows you to draw a figure and send it to the network. The drawing is composed of shapes and each shape (class InDShape) is composed of points. For the drawing to be sent to the network, i add the shapeVector (== drawing) to the class named InDData (this class allows me to add some more information about the client and the object sent, not shown here) and then i write the object InDData created in the ObjectOutputStream.
Before writing InDData to the ObjectOutputStream, i test to see if it has a good shapeVector by drawing the shapeVector at the screen. This always shows the same copy as the last drawn panel.
We suppose that the drawing is sent to the network after each drawn shape
(mousePressed -> mousseDragged -> mousseReleased)
(<------------------------------- shape ------------------------------->)
now the problem ;)
When i start drawing, the first shape is sent through the network without any problem.
As soon as i add a second shape to the drawing (shapeVector.size() == 2) things get weird.
The drawing sent to the network is made only of the first shape, nothing more.
     output of program after the 2nd shape was drawn
     client print 1 : size is 2
     server print 2 : size is 1
Alright seems like the shapeVector is truncated...
Now i tried something else to see if the it's only the Vector which is truncated or anything else.
After adding a second shape to the drawing, i delete the first shape of it:
     reprenstation of the shapeVector:
     ([shape1])
     ([shape1][shape2]) // added the 2nd shape
     ([shape2]) // deleted the first shape
     ([shape2][shape3]) // added a third shape. Vector sent to the network via InDData
     output of program with the vector shown above
     client print 1 : size is 2
     server print 2 : size is 1
Additionnaly you might expect me to say that first element of shapeVector inside both class InDData (client and server) are the same, but unfortunately they are not.
The shapeVector received by the server via InDData is the same as when i drew the first shape :((
Here is the problem (!) :(
I think that i have a variable that is not overwritten somewhere but i don't know because:
objectData is overwritten each time a message is sent to the server and has the correct values inside.
objectData2 is overwritten each time a message is received from clients.
Sorry for the huge post, but i believe that explanations are necessary ;)
I am using the 1.4.2 jvm (not tested on others) with Xcode (apple powerbook g4 12").
Thank you all :)

Answer 1

Update :)
In my way of making my program "simple" i forgot an important point in the client side :
// client side
ObjectOutputStream p = new ObjectOutputStream(new BufferedOutputStream (connection.getOutputStream()));
while (connectionNotEnded)
     synchronized (waitingVector)
          try
               waitingVector.wait();     // the only purpose of the Vector is to make the thread wait until it is interrupted to send InDData
          catch (InterruptedException ie)
               System.out.println("Thread interrupted");
     InDData objectData = (InDData) vectorObjectsToBeSentThroughNetwork.remove(0);
     System.out.println(objectData.getShapeVectorSize(); //print 1
     p.writeObject(objectData);
     p.flush();
I need it to explain the solution of my problem.
when I am creating a client, a thread is created with the above code. It creates the ObjectOutputStream and then wait patiently until said to proceed (Thread.interrupted()).
I do not close the ObjectOutputStream during the program running time.
So whenever I am writing an object to the stream, the stream "sees" if the object was created before. I suppose that the ObjectOutputStream has a kind of memory for past written objects.
So when i send the first InDData, the ObjectOutputStream's memory is "empty", thus the correct sending (and serialization) of InDData.
But whenever I try to write another object of the same type InDData containing approximately the same data (shapeVector), the ObjectOutputStream calls its "memory" and tries to find it in the past written objects. And finds it in my case ! That's why whatever i put in the shapeVector, it ends by being the first shapeVector sent through the network. (I assume that the recall memory process lacks of "precision" in identifying the memory's object or that the process to give a unique serial to the written object in the ObjectOutputStream "memory" is limited).
I tried the different ObjectOutputStream writing methods :
instead of p.writeObject(objectData) i put p.writeUnshared(objectData).
But as it is said in the docs : " While writing an object via writeUnshared does not in itself guarantee a unique reference to the object when it is deserialized, it allows a single object to be defined multiple times in a stream, so that multiple calls to readUnshared by the receiver will not conflict. Note that the rules described above only apply to the base-level object written with writeUnshared, and not to any transitively referenced sub-objects in the object graph to be serialized."
And that is exactly my case !
So i had to take it to the next level :)
instead of trying to make each written object unique, i simply reset the stream each time it is flushed. That allows me to keep the stream opened and as fresh as new ;) I think the cost of resetting the stream is higher than writeUnshared but lower than closing and creating a new stream each time otherwise it would not have been implemented ;)
Here is the final code for the client side, the server side remains unchanged :
// client side
ObjectOutputStream p = new ObjectOutputStream(new BufferedOutputStream (connection.getOutputStream()));
while (connectionNotEnded)
     synchronized (waitingVector)
          try
               waitingVector.wait();     // the only purpose of the Vector is to make the thread wait until it is interrupted to send InDData
          catch (InterruptedException ie)
               System.out.println("Thread interrupted");
     InDData objectData = (InDData) vectorObjectsToBeSentThroughNetwork.remove(0);
     System.out.println(objectData.getShapeVectorSize(); //print 1
     p.writeObject(objectData);
     p.flush();
     p.reset();
And that solves my problem :)