Probleme mit ArrayList

[R0flC0pterpiL0t]

Abend die Leute,

ich habe hier ein kleines Verständnisproblem mit der ArrayList, das ich so schnell nicht durch Google oder durch ein KSKB lösen konnte (s.u.). Eigentlich muss die Lösung doch sehr leicht sein, aber irgendwie komme ich nicht drauf.

import java.util.ArrayList;
public class ArrayListTest
{
  public static void main(String[] args)
  {
    ArrayList<int[]> list = new ArrayList<int[]>();
    int[] loc = new int[2];
    int i;
    loc[0] = 1;
    loc[1] = 1;
    list.add(loc);
    for (i=0;i<10;i++) 
    {
      loc[0]++;
      list.add(loc);
      System.out.println(loc[0]);
    } // end of for
    
    for (i=0;i<list.size();i++) 
    {
      System.out.println("list[" + i + "]: " + list.get(i)[0] + " " + list.get(i)[1]); 
    } // end of for
  }
}

eigentlich habe ich folgende Ausgabe in der letzten for-Schleife erwartet:

list[0] : 1 1
list[1] : 2 1
list[2] : 3 1
list[3] : 4 1
list[4] : 5 1
list[5] : 6 1
list[6] : 7 1
list[7] : 8 1
list[8] : 9 1
list[9] : 10 1
list[10] : 11 1

aber es kommt folgendes raus:

list[0] : 11 1
list[1] : 11 1
list[2] : 11 1
list[3] : 11 1
list[4] : 11 1
list[5] : 11 1
list[6] : 11 1
list[7] : 11 1
list[8] : 11 1
list[9] : 11 1
list[10] : 11 1

... warum ?

Tut mir leid, wenn diese Frage so dämlich ist, so kommt sie mir nämlich auch vor ...

aber ich hoffe, ihr könnt mir mal kurz unter die Arme greifen, normalerweise schaffe ich es meist selbst irgendwas zu beheben, weil ICH einen Verständnisfehler hatte, aber aus diesem Fehler werde ich echt nicht schlau, sowie aus der API der Klasse ArrayList nicht ...

 

[stg]

Du packst 11 mal das selbe Array in deine Liste. Du änderst zwar zwischendurch die Werte, die in diesem Array vorgehalten werden, aber es ist und bleibt ja trotzdem das selbe Array. (In der Liste speicherst du nicht den aktuellen Zustand des Arrays, sondern nur eine Referenz)

 

[R0flC0pterpiL0t]

Du packst 11 mal das selbe Array in deine Liste. Du änderst zwar zwischendurch die Werte, die in diesem Array vorgehalten werden, aber es ist und bleibt ja trotzdem das selbe Array. (In der Liste speicherst du nicht den aktuellen Zustand des Arrays, sondern nur eine Referenz)

wenn es immer nur die Referenz in die Liste speichern würde, dann würde es doch immer nur den aller ersten Zustand des Arrays, nämlich {1, 1} speichern ?

Tut mir leid, wenn ich dich missverstanden habe, aber so wie ich das verstehe, ist die Referenz eines Arrays doch immer der "Speicherort", der ausgegeben wird, wenn man System.out.print(arrayname) dem Compiler sagt bzw. die erste Zuweisung eines Werts, da das Array ja von diesem Wert ab dann referenziert.

Aber die Liste ist voll mit Arrays mit dem Wert {11, 1} ... das heißt doch, dass sie schon den geänderten Arrayzustand "angenommen" hat, bloss dass sie aus irgendeinem mir nicht ersichtlichen Grund es für nötig hält, die zuvor übergebenen Arrayzustände zu überschreiben ...



hab hier ein besseres KSKB geschrieben (selbes Problem):

ArrayList<int[]> list = new ArrayList<int[]>();
    int[] loc = new int[2];
    int[] newLoc;
    int i;
    loc[0] = 1;
    loc[1] = 1;
    list.add(loc);
    loc[0] = 2;
    list.add(loc);
    loc[0] = 3;
    list.add(loc);
    
    for (i=0;i<list.size();i++) 
    {
      System.out.println("list[" + i + "]: " + list.get(i)[0] + " " + list.get(i)[1]); 
    } // end of for

 

[taro]

Tut mir leid, wenn ich dich missverstanden habe, aber so wie ich das verstehe, ist die Referenz eines Arrays doch immer der "Speicherort", der ausgegeben wird, wenn man System.out.print(arrayname) dem Compiler sagt [...]

Richtig! Somit hast du in deiner ArrayList jedes mal die gleiche Referenz (und keine Werte!). Änderst du das Array ab, so ändern sich auch die Ausgabewerte.

ArrayList<int[]> list = new ArrayList<int[]>();
    int[] loc = new int[2];
    int[] newLoc;
    int i;
    loc[0] = 1;
    loc[1] = 1;    // Werte im Array: [1,1]
    list.add(loc); // Momentane Ausgabe wäre "list[0]: 1 1"
    loc[0] = 2;   // Werte im Array: [2,1]
    list.add(loc); // Momentane Ausgabe wäre "list[0]:2 1" "list[1]: 2 1"
    loc[0] = 3;   // Werte im Array: [3,1]
    list.add(loc); // Ausgabe ist nun "list[0]:3 1" "list[1]: 3 1" "list[2]: 3 1" - du zeigst ja 3 mal auf das selbe Array

bzw. die erste Zuweisung eines Werts, da das Array ja von diesem Wert ab dann referenziert.

Die Referenz ist lediglich die Adresse im Speicher - der Wert ist vollkommen egal.

Aber die Liste ist voll mit Arrays mit dem Wert {11, 1}

Nein, die Liste ist befüllt mit Referenzen (also der Speicheradresse) auf ein und das selbe Array.

... das heißt doch, dass sie schon den geänderten Arrayzustand "angenommen" hat, bloss dass sie aus irgendeinem mir nicht ersichtlichen Grund es für nötig hält, die zuvor übergebenen Arrayzustände zu überschreiben ...

Und wieder: Du hast in der Liste keine Arrayzustände, sondern lediglich Referenzen auf ein Array (und bei dir eben immer auf das selbe Array).

Um das von dir gewünschte Ergebnis zu erreichen, musst du ein neues Array der Liste hinzufügen

 

[R0flC0pterpiL0t]

Ah ok, jetzt habe ich es verstanden, danke Davor war mir das ganze mit Referenz noch nicht so klar, weil ich mich noch nicht so sehr damit auseinandersetzen musste, was das noch so alles für meine Projekte bedeutet

Hab mir jetzt nochmal einen Code geschrieben, der mir das nochmal vorgeführt, woran es eigentlich liegt. Vielleicht bringt es ja jemand zukünftigen etwas, das leichter zu verstehen. Nichts gegen eure Erklärungen, durch eure Erklärungen konnte ich es mir ja erst überhaupt vorstellen, was da eigentlich passiert.

  ArrayList<int[]> list = new ArrayList<int[]>();
    int[] loc = new int[2];
    int[] newLoc;
    int i;
    loc[0] = 1;
    loc[1] = 1;
    list.add(loc);
    loc[0] = 2;
    
    System.out.println(list.get(0)[0] + " " + list.get(0)[1]);

Ausgabe:

2 1

trotz keiner erneuten Übergabe, da die Liste nur den Speicherort referenziert.

Das heißt, sobald ich es ändere, werden bereits die neuen Werte von der Liste ausgegeben, da sie ja nur das Array referenziert, erneut übergeben muss ich also gar nicht erst, damit sich die alten Werte in der Liste auch ändern.

Vielen Dank !

Hab das Problem jetzt einfach mit zwei ArrayList<Integer> gelöst, um zu vermeiden, immer ein neues Array zu erstellen ... das sollte mir die Liste nämlich eigentlich weggnehmen

ArrayList<Integer> listX = new ArrayList<Integer>();
    ArrayList<Integer> listY = new ArrayList<Integer>();
    int x,y,i;
    x = 1;
    listX.add(x);
    y = 1;
    listY.add(y);
    x = 2;
    listX.add(x);
    listY.add(y);
    x = 3;
    listX.add(x);
    listY.add(y);
    
    for (i=0;i<listX.size();i++) 
    {
      System.out.println(listX.get(i) + " " + listY.get(i)); 
    } // end of for

 

[stg]

Unabhängig von deiner eigenentlichen Frage: Wertepaare sollten auch (fast) immer als Wertepaare abgespeichert werden. Der Ansatz mit dem Array ist schon nichtso verkehrt, besser wäre vermutlich noch einen eigenen Wrapper zu schreiben, den du in deine Liste packst.

public class Punkt2D {
  private int x;
  private int y;

  public Punkt2D(int x, int y) {
    this.x = x;
    this.y = y;
  }

  public int getX() { return this.x; }
  public int getY() { return this.y; }
}

Dein Code aus dem ersten Post würde damit ungefähr so aussehen:

    import java.util.*;
    public class ArrayListTest
    {
      public static void main(String[] args)
      {
        List<Punkt2D> list = new ArrayList<>();        
        for (i=0;i<10;i++)
        {
          list.add(new Punkt2D(i,0));          
        }
       
        for (i=0;i<list.size();i++)
        {
          System.out.println("list[" + i + "]: " + list.get(i).getX() + " " + list.get(i).getY();
        } 
      }
    }

(habs nicht getestet, sondern nur frei Hand hier schnell runtergeschrieben. Soll dir nur als Anregung dienen )

 

[R0flC0pterpiL0t]

Ok super danke, hab meinen Backtracking-Algorithmus jetzt mit einer Wrapper-Klasse funktionsfähig gemacht ... das andere mit den zwei ArrayList<Integer> sah schon nach Optimierungsbedarf aus