Collections Arrays in ArrayList abspeichern

[dbrust_2000]

Ich habe folgendes Problem. Ich möcht int-Arrays in einer ArrayList abspeichern. In einer Testklasse habe ich folgendes probiert. und das geht auch:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class JavaArrayListOfStringArray {

    public static void main(String[] args) {
        // List of String arrays
        ArrayList<int[]> list = new ArrayList<int[]>();
       
        int[] arr1 = new int[3];
        int[] arr2 = new int[4];
        arr2[0]=1;arr2[1]=2;arr2[2]=3;arr2[3]=4;
        arr1[0]=1;arr1[1]=2;arr1[2]=5;
        list.add(arr1);
        list.add(arr2);
        // printing list of String arrays in the ArrayList
        for (int[] strArr : list) {
            System.out.println(Arrays.toString(strArr));
        }
    }

}

Nun habe ich das nDamenProblem implementiert und ich möchte halt alle Lösungen (die habe ich als Array angelegt) in einer ArrayList speichern. Aber wenn ich das so mache wie oben, legt er zwar die Arrays an, die sind aber nicht gefüllt.

import java.util.*;



public class NDamenProblem
{
    private int m[]; //meine Loesung
    private int n; // Dimension des Problems
    private int anz; //Anzahl der Loesungen
    //private List<String> speicher; //damit geht es, aber
    private ArrayList<int[]> speicher;// ich möchte es so machen
    public NDamenProblem(int n){
        //m = new int [4];
        this.n=n;
        //speicher = new List<String>();
        speicher = new ArrayList<int[]>(); //speicher initialisiert!
        m=new int [n];
        Arrays.fill(m,0);
        anz = 0;
    }

    public void behandleKnoten(){
        behandleKnoten(0);
        System.out.println("Lösungen: " + anz);
    }

    private void behandleKnoten(int ebene){
        if (ebene == n){ 
            anz++;
            //System.out.println(anz+". Lösung: "+ Arrays.toString(m)); //Das geht! in m stehen wirklich Werte>0
            //speicher.append(Arrays.toString(m)); // Das geht auch
            speicher.add(m); //aber hier hat m nur die Werte 0!!!
        }
        else{
            for(int j = 1; j<n+1;j++){ 
                if(pruefe(j,m,ebene)){
                    m[ebene]=j;
                    behandleKnoten(ebene+1);
                }
            }
            m[ebene]=0;
        }
    }

    private boolean pruefe(int zahl, int[] a, int ebene){

        for (int i = 0;i<ebene;i++){
            //schaue, in die Spalte
            if (zahl == a[i]){
                return false;
            }
            // Schaue in die Diagonalen
            if(zahl == a[ebene-i-1]+1+i || zahl == a[ebene-i-1]-1-i ){
                return false;
            }
        }

        return true;
    }

    /*
    public List<String> getSpeicher(){
    return this.speicher;
    }*/

    public ArrayList<int[]> getSpeicher(){
        return this.speicher;
    }

    //End GetterSetterExtension Source Code
    //!
}

 

[dbrust_2000]

Noch ne main-Methode zum Testen

    public static void main(String[] args) {
        NDamenProblem ndp = new NDamenProblem(4);
        ndp.behandleKnoten();
        int[] arr1 = ndp.getSpeicher().get(0);
        int[] arr2 = ndp.getSpeicher().get(1);
        
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr2));
    }

 

[Kirby.exe]

Naja deine Arrays.fill() Methode bekommt eine 0 übergeben, somit ändert es nichts am Array Da int ein primitiver Datentyp ist, wird das Array an allen Stellen mit 0 initialisiert Probiere mal Arrays.fill(m,1);

 

[temi]

Naja deine Arrays.fill() Methode bekommt eine 0 übergeben, somit ändert es nichts am Array

Das ist nicht das Problem. Der Inhalt von "m" wird ja später in der rekursiven Methode geändert.

speicher.add(m);

Wenn diese Stelle zum ersten Mal aufgerufen wird, dann enthält m tatsächlich Werte ungleich 0. Du fügst der ArrayListe danach eine Referenz auf dieses m hinzu.

Allerdings wird durch die rekursiven Aufrufe danach der else-Zweig noch einigemal durchlaufen. Du arbeitest allerdings immer auf dem selben "m". Damit werden auch die Werte des bereits in der Arrayliste enthaltenen "m" verändert. Es ist ja eine Referenz auf das eine "m" das es gibt.

Ich habe keine Ahnung was dein Code genau macht, aber versuche mal der ArrayListe eine neue Kopie von "m" zu übergeben (Arrays.copyOf()). Dann werden in der Liste Referenzen auf verschiedene Arrays gespeichert.

Hier noch mal zur Verdeutlichung:

public static void main(String[] args) {

    int[] m = new int[4];

    ArrayList<int[]> list = new ArrayList<>();

    list.add(m); // Liste bekommt eine Referenz auf das Array m übergeben.

    m[0] = 42;

    // Beide Referenzen zeigen auf das selbe Array
    // deshalb wirkt sich jede Änderung an einem der "beiden" Arrays
    // auch auf das "andere" Array aus (es gibt ja nur EIN Array)
    System.out.println(Arrays.toString(m));
    System.out.println(Arrays.toString(list.get(0)));

    list.get(0)[1] = 1;

    System.out.println(Arrays.toString(m));
    System.out.println(Arrays.toString(list.get(0)));

}

Ausgabe

[42, 0, 0, 0]
[42, 0, 0, 0]
[42, 1, 0, 0]
[42, 1, 0, 0]

 

[dbrust_2000]

Hi Temi,

aber versuche mal der ArrayListe eine neue Kopie von "m" zu übergeben (Arrays.copyOf())

Das klappt! Vielen Dank.

Und eigentlich habe ich es auch verstanden, trotzdem wundere ich mich ein wenig, dass das bei Strings funktioniert. Da werden doch auch Referenzen übergeben, oder habe ich da etwas nicht kapiert?

Liebe Grüße

Daniel

 

[kneitzel]

Strings sind unmutable, d.h. eine Referenz auf einen String wird immer auf den gleichen String verweisen. Bei einer Veränderung wird ein neuer String erstellt und Du bekommst somit ständig neue Referenzen.

 

[dbrust_2000]

achso