Schiebefix - ArrayList überschreibt Daten

[PDog]

Wir haben die Aufgabe von der FH einen Schiebefix zu programmieren, dabei ist das meiste schon vorgegeben, wir müssen quasi nur den SchiebefixState programmieren. Hier stellt sich mir aber das Problem, dass die ArrayList mit möglichen Nachbar States in der Methode getNeighbours immer wieder die Daten überschreibt und auch der "UrspungsState" immer überschrieben wird. Ich stehe hier ziemlich auf dem Schlauch und wäre für jede Hilfe dankbar.

Also es geht nur um die Methode getNeighbours() {


Code:

import java.util.*;


public class SchiebefixState implements State
{
    private final int[][] schiebetafel;
    private final int freeX;
    private final int freeY;
    private final int N;

   
    public SchiebefixState(int[][] tafel, int x, int y){
        if (tafel[x][y]!=0)
            throw new IllegalArgumentException("Field (" +x+","+y+") must be free (0).");
        this.schiebetafel = tafel;
        this.freeX = x;
        this.freeY = y;
        this.N = tafel.length;
    }
    

    
    
    /**
     * Liefert eine Liste mit allen gueltigen Nachfolgezustaenden.
     */
    @Override    
    public List<State> getNeighbours() {
        //=============================================
        //Züge durch zwei Arrays darstellen
        int [] zugX =  {0, 1, 0, -1};
        int [] zugY =  {1, 0, -1, 0};
        
        //Es gibt maximal 4 Zugmöglichkeiten, also maximal 4 Nachbarn
        List<State> neighbours = new ArrayList();
        
        for (int i = 0; i < zugX.length; i++) {
            //prüfen ob Zielfeld noch im Schiebefeld liegt
            int bewX = zugX[i];
            int bewY = zugY[i];
            if( (freeX + bewX + 1)> 0 && (freeY + bewY + 1)> 0 && (freeX + bewX )< N && (freeX + bewY )< N ) {
                // Nun neuen State mit entsprechend vertauschten Feldern
                //Erst aktuelle Tafel übernehmen
                
                
                
                    int[][] neighbour  = schiebetafel;
                    // Felder vertauschen
                    neighbour[freeX][freeY]= neighbour[freeX + bewX][freeY + bewY];
                    neighbour[freeX + bewX][freeY + bewY] = 0;
                    int newX = freeX + bewX;
                    int newY = freeY + bewY; 
    
                    
                        
                    neighbours.add(new SchiebefixState(neighbour, newX, newY)); 
                    
                    //Änderungen rückgängig machen, damit sich die gespeicherten nicht durchegehend ändern
                    //new entspricht den alten freeX und freeY
                    newX = newX - bewX;
                    newY = newY - bewY;
                    
                    neighbour[newX + bewX][newY + bewY] = neighbour [newX][newY];
                    neighbour[newX][newY] = 0;
                    
                    State versuch = new SchiebefixState (neighbour, newX, newY);
                
                
            }
        }
        
                
        return neighbours; 
        
        //=============================================        
    }
    
    
}

 

[berndoa]

Schreib deinen Code am Besten mal innerhalb von code tags (dazu im Editor auf den button mit den < > klicken), denn anders, wie jetzt hier, sieht man keinerlei Formattierung oder Zeileneinrückungen, was das Lesen enorm erschwert.

 

[mrBrown]

Schreib deinen Code am Besten mal innerhalb von code tags (dazu im Editor auf den button mit den < > klicken), denn anders, wie jetzt hier, sieht man keinerlei Formattierung oder Zeileneinrückungen, was das Lesen enorm erschwert.

In dem Fall dein Beitrag am besten auch Melden, dann kann die Formatierung von Admins & Moderatoren auch für bestehende Beiträge noch angepasst werden 🙂

 

[Robertop]

Das Problem ist in Zeile 47:

int[][] neighbour  = schiebetafel;

Hier wird keine Kopie von schiebetafel erzeugt, sondern bloß eine neue Referenz zum selben Objekt gesetzt. Wenn du in den Zeilen darunter also in neighbour schreibst, schreibst du in dasselbe Objekt wie schiebetafel.

Für Ein-Dimensionale Arrays gibt es in Java eine Copy-Funktion "Arrays.copyOf". Für mehrdimensionale Arrays kann man sich eine Schleife zusammenbauen:

    private int[][] copySchiebetafel() {
        int[][] destArray = new int[N][];
        for (int i = 0; i < N; i++) {
            destArray[i] = Arrays.copyOf(schiebetafel, N);
        }
        return destArray;
    }