Wysyłanie obiektu po zmianie TCP

Mam problem z wysyłaniem obiektu protokołem TCP. Po wysłaniu pierwszym i zmianie, obiekt zostaje wysłany ponownie. Klient jednak wydaje się że uzyskał obiekt bez zmian. ;/

Tak wygląda wysyłanie serwera i pobieranie klienta.

if(client.equals("0")){
                c.createServer(50009);
                c.waitClient();
                Map map = new Map();
                map.add();
                c.sendObjTCP(map);
                System.out.println(map.list.get(0).x+" "+map.list.get(0).y);
                for(int i=0;i<5;i++){
                    map.update();
                    System.out.println(map.list.get(0).x+" "+map.list.get(0).y);
                    c.sendObjTCP(map);
                }
                System.out.println(c.getLogs()); //wyświetla logi
                c.disconnect();
            }else{
                c.joinServer("localhost", 50009); 
                test =(Map)c.getObjTCP(0);
                System.out.println(test.list.get(0).x+" "+test.list.get(0).y);
                for(int i=0;i<5;i++){
                    test =(Map)c.getObjTCP(0);
                    System.out.println(test.list.get(0).x+" "+test.list.get(0).y);
                }
                System.out.println(c.getLogs()); //wyświetla logi
                c.disconnect();          
            }

Serwerowi wyświetla:

-20.0 299.0
-18.6722 298.79877
-17.344398 298.59753
-16.016598 298.3963
-14.688797 298.19507
-13.360996 297.99384
null

Klientowi zaś:

-20.0 299.0
-20.0 299.0
-20.0 299.0
-20.0 299.0
-20.0 299.0
-20.0 299.0
null

Tak zaś wyglądają klasy wysyłanych obiektów:

class Map implements Serializable{
    
    ArrayList<Mob> list = new ArrayList<>();
    
    public void add(){
        list.add(new Mob());
    }

    public void update(){
        for(Mob m:list){
            m.update();
        }
    }
    
    
}

class Mob implements Serializable{
    float x,y;
    int speed;
    int speedforp;
    float xsp,ysp;
    static int times=1;

    Mob(){
       randomPos(); 
    }

    
    public void anim(int sx, int sy,int ex, int ey,int speed){
        x=sx;
        y=sy;
        speedforp=speed;
        this.speed=speed;
        xsp=(ex-sx)/(float)speed;
        ysp=(ey-sy)/(float)speed; 
    }
    
    public void update(){
        if(speed>=0){
            x+=xsp;
            y+=ysp;
            speed-=1;
        }else{
            randomPos();
            times++;
        }
        
    }
    
    Random r = new Random();
    
     public void randomPos(){
        int dir = r.nextInt(4)+1;
        int speedi= r.nextInt(300)+200;
        if(dir==1){
            int y=420;
            int x = r.nextInt(600);
            int fx= r.nextInt(600);
            anim(x, y, fx, -20, speedi);
        }
        else if(dir==2){
            int x=620;
            int y = r.nextInt(400);
            int fy = r.nextInt(400);
            anim(x, y, -20,fy , speedi);
        }
        else if(dir==3){
            int y=-20;
            int x = r.nextInt(600);
            int fx= r.nextInt(600);
            anim(x, y, fx, 420, speedi);
        }
        else if(dir==4){
            int x=-20;
            int y = r.nextInt(400);
            int fy = r.nextInt(400);
            anim(x, y, 620, fy, speedi);
        }
    }
    
}

W przypadku wysyłania obiektów innych klas wszystko działa poprawnie np. String lub zwykła Klasa posiadająca różnego typu dane.

Nie wiem co jest tego powodem, ale znalazłem sposób na to aby to działało ale powodu dla którego pierwszy sposób nie działa nie znam.

Jest tak:

obtabout.get(0).writeObject(new ObjectStream(v));

Jak to działa: Zawieranie obiektu w Klasie służącej jako strumień TCP

W każdym razie obiekt nazwany tu v tylko dojdzie poprawnie jeśli zostaje wysłany po jego świżym utworzeniu np.

sendObjTCP(new JakasKlasa(kontruktor));

Jeśli zaś zrobie tak:

JakasKlasa obiekt = new JakasKlasa(kontruktor);
sendObjTCP(obiekt); //<-zostanie wysłane poprawnie i odebrany poprawnie
obiekt.setcos(xx); //<-zmiana jego
sendObjTCP(obiekt); //<- teraz zostanie wysłany, ale po odebraniu wygląda na to że jest taki jak przedz zmianą ;/

Dlaczego tak się dzieje ?

Kiedyś pisałem mały projekt, który wykorzystywał ObjectOutputStream do wysyłania obiektów przez socket i miałem taki sam problem.

MyClass object= new MyClass();
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(object);
object.setVariable(2);
oos.writeObject(object);

To dawało na input streamie dwa takie same obiekty, mimo iż użyłem setVariable. Doszukałem się rozwiązania na necie, lecz nigdy nie doczytałem dokładnie dlaczego ono działało.

MyClass object= new MyClass();
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(object);
oos.flush();    // <----- 
oos.reset();    // <-----
object.setVariable(2);
oos.writeObject(object);

Po dodaniu flush i reset drugi obiekt, który przychodził na input streamie był zmieniony.

O ile czegoś nie zapomniałem, to tak to było. Może ktoś z bardziej doświadczonych forumowiczów się wypowie (ew. skarci mnie za pisanie głupot :P).

Zajrzyj tu http://4programmers.net/Forum/Java/204328-serializacja_-_dziala_tylko_raz?p=881565#id881565