deep copy mehrdimensionaler Arrays

[winterwanderer]

Hallo,
ich habe grade ein paar nette Stunden mit Fehlersuche zugebracht, die mich gelehrt haben auf die feinen Unterschiede zwischen tiefer und flacher Kopie zu achten.
Ich habe nämlich mein geklontes Objekt munter verändert und bei späteren Zugriffen auf mein Ursprungsobjekt, das eigentlich hätte unverändert bleiben sollen, mich sehr gewundert, was mit dem passiert war.
Ok, das kopierte Objekt enthält als Attribute Referenztypen und die muss ich wohl bei meinem Klon extra mit kopieren, soviel habe ich gelenrt. Unter anderem ist da auch ein mehrdimensionaler Array mit dabei und in Java ist eine Insel hab ich nun gelesen, dass da bei einer Kopie nur mein erster Index tiefkopiert wird und mein zweiter nicht. So'n Scheiß!! :cry:
Wie bekom ich das denn hin.
Ok, ich könnte per Hand einen einen neuen Array anlegen und dort über zwei for Schleifen alles reinkopieren, aber da ich sehr viele kopien anlegen muss, befürchte ich dass das viel zu lange dauert.
Wenn jemand eine Idee hat, wärs schön.
Hier nun meine Klasse mit den Attributen.

 public class ZugBewertung implements Cloneable {//Hilfsklasse zur Übergabe der Variablen an den Min-Max-Zugbewerter
            public int gesamtWeissKugeln;
            public int [][] fbeleg;
             public double [] [] fwert;
            public  double wZahl;
            public int feldwertWZug;

 

[Wildcard]

Das bezieht sich vermutlich auf den letzten Thread von dir.
Unter Berücksichtigung dessen was du vorhast, und da das nach sehr speicherintensiven Objekte ausieht rate ich dir vom clonen ab, und schlage dir erneut vor deine Änderungen stattdessen zurückzunehmen (ja, ich weiß dass das arbeit ist, aber du kannst doch nicht ständig wild Arrays umkopieren :? )

 

[winterwanderer]

Du wirst mich schon noch weich kloppen. Ich möchte jetzt mein Programm aber gerne erst mal zum Laufen bringen und dafür ist es eben am einfachsten die Klone anzulegen. Anschließend wolte ich mir das mit dem Memento Objekt nochmal genauer anschauen.
Aber ist so ein Memento denn letztlich auch nichts anderes als ein Klon? Zwar gekapselt und gegen Zugriff geschützt, aber dennoch eine Kopie oder ?
Das Problem bei meinem rekursiven Spielbaum ist ja, dass es auch nicht ausreicht einmal ein solches Objekt anzulegen. Ich muss ja bei jedem neuen Pfad darauf zurückgreifen können und leider kann ich mich aus meiner Rekursionsschleife ja nicht mal kurz verabschieden um es dann von außen wieder reinzuholen.
Im Moment seh ich keine klare Lösung. Ein schrittweises Rücksetzen eines Zuges ist auch Mist, da der sich wirklich kaskadierend über ein ganzes Spieleld ausbreiten kann.
Ich hatte ursprünglich gedacht, ich könnte in Java so etwas wie eine in-Variable einer imperativen Sprache nachbauen. Also Variable in Empfängerklase schicken. Dann am Ende meine benötigte Infomration (einer anderen Variablen) entnehmen und anschließend mit meiner unveränderten Ursprungsvariablen weiter arbeiten. Das scheint aber nicht zu klappen.
Anscheinend bilden die Objektorientierten Sprachen, die Realtität hier leider beser ab. Ich kann ja auch nicht erwarten eine verborgene Information über den Zustand meines Automotors zu bekommen und mein Auto unverändert zurückzuerhalten (zumindest wenn nicht alles zurückgesetzt wurde.)
Mist. Ich seh im Moment keine klare Lösung. Falls dir was einfällt, wär ich froh!
(Auch wenn ich's vielleicht nicht direkt auf der Stelle umsetze :wink:
Ps Für die anderen Leser: Um zu verstehen, um was es hier geht, müsst ihr wahrscheinlich den Thread
'Attribut nur in Unterklasse ändern' vom 27.8. anschauen. Tschuldigung

 

[Wildcard]

Für einen echten Klone musst du dann entweder die Arrays manuell mit System.arraycopy umkopieren (die 2te ebene selbst auflösen), oder mit Objektserialisierung arbeiten.

 

[Estrados]

Schau dir das mal an, das hat mir bei dem Problem sehr gut weitergeholfen:

An alternative to the deep copy technique

 

[byte]

Die Alternative mit der Serialisierung ist zwar einfacher, aber auch langsamer als das Kopieren per Cloneable oder Copy-Konstruktor. Letzteres würde ich bevorzugen, aber das muss jeder selbst entscheiden.

 

[winterwanderer]

Den Link mit der Serialisierung habe ich mir auch mal angeschaut. Ist sicher oft eine schöne Alternative. Leider wird dort auch beschrieben, dass es deutlich langsamer ist und aher scheidet es für mine Anwendung leider aus.
Wie das arraycopy bei 2.dimensionalen Arrays funktioniert habe ich nicht richtig kapiert. Da findet man auch im Netz nix genaues drüber außer dem Hinweis man müßte eben die einzelnen Dimensionen einzeln mit arraycopy abhandeln. Ist mir aber im Moment nicht klar wie das genau geht.

 

[Wildcard]

Einfach ein neues Array von Arrays erstellen, und für jedes enthaltene Array arraycopy aufrufen

 

[winterwanderer]

Ich habe grade äußerst überrascht festgestellt, dass es noch viel simpler geht, zumindest bei quadratischen Arrays klappt das. Man schert sich überhaupt nicht darum, ob ein Array eindimensional oder zweidimensional oder sonstwas ist und ruft einfach arraycopy auf - und entgegen aller anderslautender Verlautbarungen wird das gesamte zweidimensionale Array kopiert. Wenn ihr's wie ich nicht glauben wollt, ruft einfach mal meine Klasse ArrayKopie auf- und staunt.

 public class ArrayKopie {

  
        int [][] source;
        int [][] empf;
  
           
           ArrayKopie(){
               
             //initialisiert Quellarray  
            source=new int [10][10];
           for (int i=0; i<10;i++) {
               for (int j=0; j<10;j++) {
                  source[i][j]=i-j;
               }
           }
           //initialisiert Empfängerarray
           empf = new int [10][10];
           
           // und nun kommt ein einzelner!!! arraycopy-Aufruf
           System.arraycopy(source,0,empf,0,10);
          
           // zum Überprüfen, das ganze ausgedruckt.
           for (int i=0; i<10;i++) {
               for (int j=0; j<10;j++) {
                   System.out.println(empf[i][j]);
               }
           }
        }       
}

 

[Wildcard]

Wenn ihr's wie ich nicht glauben wollt, ruft einfach mal meine Klasse ArrayKopie auf- und staunt.

Und jetzt füg am Ende mal diese Zeilen ein und staune :wink:

        empf[0][0]=100;
        System.out.println(Arrays.toString(source[0]));
        System.out.println(Arrays.toString(empf[0]));

Du hast ein ShallowCopy gemacht :lol:

 

[winterwanderer]

ok, lassen wirs gut sein, es wär zu schön gewesen.

 

[winterwanderer]

Vielleicht ist es ja nochmal für irgendjemand von Interesse, der auch mehrdimensionale Arrays tief kopieren möchte.
Ich hab mein Progrämmchen nun so umgebaut, dass es diesmal wirklich klappt.

public class ArrayKopie {

  
        int [][] source;
        int [] empfx;
        int[][] empf;
   
        
            
        ArrayKopie(){
               
             //initialisiert Quellarray  
            source=new int [10][8];
           for (int i=0; i<10;i++) {
               for (int j=0; j<8;j++) {
                  source[i][j]=i-j;
               }
           }
           //initialisiere Empfängerarrays
           empf = new int [10][8];
          for (int i=0;i<10;i++) {
               empfx  = new  int [8];
               System.arraycopy(source[i],0,empfx,0,8);
               System.arraycopy(empfx,0,empf[i],0,8);
          }    
  
         
           for (int i=0; i<10;i++) {
               for (int j=0; j<8;j++) {
                  empf[i][j]=empf[i][j]*10;
               }
           }   
      
           System.out.println("empf[3][8]" +empf[3][5] );
           System.out.println("source[3][8]" +source[3][5] );
               
       }  
}   //Juchu klappt