Buongiorno a tutti,

è da ieri che sto cercando un modo per risolvere questo strano problema, ho provato a farmi aiutare anche da chi è più esperto di me in programmazione (sono poco più che un principiante) e ho cercato anche in rete ma non ho trovato ancora una spiegazione per quello che succede. Vi spiego:

codice:
public static Mossa[] Moves(){     // Metodo per calcolare tutte le mosse possibili per un giocatore.
        
        boolean bianco = false; boolean nero = false; 
        Mossa [] moves = new Mossa[50];            
        // l'array che restituirò alla fine (per semplicità di 50 elementi)
        String [] qq = stato.lastElement();        
        // array di stringhe che indentifica la posizione (matrice di oggetti Pezzo, chiamata Board)
        Posizione u = new Posizione(qq);        // la ricreò per semplicità, non è importante.

        LeggiTurno();
        if (Turno.getTurno() == 1){
            bianco = true; nero = false;
        }                                        // vedo a chi tocca muovere
        if (Turno.getTurno() == 0){
            bianco = false; nero = true;
        }
        if (bianco){
            int white = 0;                    // contatore che servirà dopo.
            
            for (int i = 0; i < u.getBoard().length; i++){ 
                
                Pezzo [] m = u.getBoard()[i];
                for (int k = 0; k < m.length; k++){ // itero su righe e colonne della matrice 
                    
                    if (u.getBoard()[i][k].Colore() == "Bianco"){  // se trovo un pezzo bianco...
                        int x = i; int y = k;
                        Casella h = new Casella(x,y);                // trovo la sua casella
                        Vector <Casella> q = Posizione.FindMoves(h); 
                        // metto in un vector tutte le possibili caselle di arrivo per quel pezzo
                        
                        for(Casella ii: q){     
                            // per ogni casella mi prendo che pezzo è ("T" è torre, ecc...)
                            
                            String pez = u.getBoard()[i][k].Repr();
                            Mossa j = new Mossa(pez, h, ii);
                            moves[white] = j;        // creo una nuova mossa e la aggiungo a moves
                            white = white + 1;    
                            // ovviamente aggiorno il contatore per non scrivere sullo stesso indice
                        }    
                    }
                }
            }
        }
        if (nero){
            int black = 0; // contatore che servirà dopo.
            
            for (int i = 0; i<u.getBoard().length; i++){
                Pezzo [] m = u.getBoard()[i];
                for (int k = 0; k<m.length; k++){         // itero su righe e colonne della matrice 
                    
                    if (u.getBoard()[i][k].Colore() == "Nero"){        // se trovo un pezzo nero...
                        int x = i; int y = k;
                        Casella h = new Casella(x,y);                // trovo la sua casella
                        Vector <Casella> q = Posizione.FindMoves(h);
                        // metto in un vector tutte le possibili caselle di arrivo per quel pezzo
                        
                        for(Casella ii: q){        
                            // per ogni casella mi prendo che pezzo è ("t" è torre, ecc...)
                            
                            String pez = u.getBoard()[i][k].Repr();
                            Mossa j = new Mossa(pez, h, ii);
                            moves[black] = j;        // creo una nuova mossa e la aggiungo a moves
                            System.out.println("Sto per aggiungere "+j+ "all indice: "+black);
                            
                            // per l'esempio (che crea una posizione in cui muove il nero) 
                            //stampo la mossa e l'indice in cui
                            // DOVREBBE aggiungere la mossa in moves.
                            black = black + 1;    
                            // ovviamente aggiorno il contatore per non scrivere sullo stesso indice
                        }
                    }
                }
            }
        }
        for(Mossa yy: moves){
            System.out.println(yy);
        }
        return moves;
    }
In cui moves è un array dove ogni elemento è una Mossa che prende in input un pezzo, una Casella di partenza e una di arrivo (sì, è un progetto di scacchi ) dove ovviamente le opportune classi sono già state definite in modo opportuno.
Il controllo di stampa che ho messo nella parte di codice definita se muove il nero mi stampa in modo corretto quello che deve stampare..in questo caso:

Sto per aggiungere r : 0,7 -> 1,6 all indice: 0
Sto per aggiungere r : 0,7 -> 0,6 all indice: 1
Sto per aggiungere c : 1,3 -> 3,4 all indice: 2
eccetera eccetera....
Sto per aggiungere t : 3,2 -> 0,2all indice: 34
dove l'indice 34 è giustamente l'ultima mossa che calcola, i metodi funzionano correttamente.

Se però faccio la stampa delle mosse dopo aver aggiunto gli elementi ecco cosa ritorna:

t : 3,2 -> 0,2
t : 3,2 -> 0,2
t : 3,2 -> 0,2
t : 3,2 -> 0,2
t : 3,2 -> 0,2

e per altre 30 volte la stessa mossa (l'ultima aggiunta) e poi una serie di null dati dal fatto che l'array l'ho creato di 50 "slot" e quindi giusto così. Ma qualcuno sa spiegarmi questo strano comportamento? Ho provato anche a cambiare il tipo di moves. All'inizio era infatti un vector <Mossa> e poi ho anche provato con un ArrayList ma stampava sempre l'ultima mossa 35 volte e non riesco a capirne il motivo, qualche gentiluomo sa aiutarmi per favore?