Multidimensionales Array zuschneiden

Diskutiere Multidimensionales Array zuschneiden im Java Basics - Anfänger-Themen Bereich.
Kirby_Sike

Kirby_Sike

Ich weiß bereits dass mein bei eindimensionalen Arrays mithilfe eines Counters, seine Größe trimmen kann:

Java:
int[]bla = new int[10];
for(int i = 0; i < 7; i++){
    bla[i] = xyz;
    counter++;
}
bla = Arrays.copyOf(bla, counter);
Jedoch wie geht dies bei Multidimensionalen Arrays, wie z.B. hier:

Java:
Labyrinth(String filename) throws Exception{
        boolean [][] gameboard = new boolean[20][20];
        int counter = 0;
        BufferedReader objReader = null;
        try {
           String strCurrentLine;
           objReader = new BufferedReader(new FileReader(filename));
           while ((strCurrentLine = objReader.readLine()) != null) {
               for(int i = 0; i < strCurrentLine.length(); i++) {
                   if(strCurrentLine.charAt(i) == 'O') {
                       gameboard[counter][i] = true;
                   }
                   if(strCurrentLine.charAt(i) == '#') {
                       gameboard[counter][i] = false;
                   }
               }
               counter++;
               System.out.println(strCurrentLine);
           }
        } catch (IOException e) {
           e.printStackTrace();
        } finally {
           try {
            if (objReader != null)
                objReader.close();
           } catch (IOException ex) {
               ex.printStackTrace();
           }
        }
       
       
      gameboard = Arrays.copyOf(gameboard, counter);  //  <--------
      arrayPrinter(gameboard);
       
    }
 
Kirby_Sike

Kirby_Sike

Das oben war nur ein Beispiel :) Eigentlich möchte ich eine Datei Parsen und die Zeichen durch true und false ersetzen und in ein 2D Array speichern :)
 
Kirby_Sike

Kirby_Sike

Na toll xD Könnte ich meine Sachen in "normale" Arrays speichern und diese Arrays dann wieder in ein Array speichern? Und wenn ja wie speichert man ein Array in ein anderes xD
 
mihe7

mihe7

Na toll xD Könnte ich meine Sachen in "normale" Arrays speichern und diese Arrays dann wieder in ein Array speichern? Und wenn ja wie speichert man ein Array in ein anderes xD
Das machst Du ja bereits :)
boolean [][] gameboard = new boolean[20][20];
gameboard[0] referenziert unmittelbar im Anschluss an diese Anweisung ein boolean Array der Länge 20. Du kannst das aber zu jeder Zeit ändern: gameboard[0] = new boolean[10]; damit referenziert gameboard[0] ein boolean-Array der Länge 10. gameboard[1] referenziert nach wie vor ein boolean-Array der Länge 20.
 
Kirby_Sike

Kirby_Sike

Ich glaube ich verstehe was du meinst, aber wenn ich doch die Referenz ändere, ändern sich dann nicht auch die Daten auf die referenziert wird?
 
Kirby_Sike

Kirby_Sike

Ich glaube ich verwirre mich mal wieder selber xD Also ich schaffe es per Counter die Zeilen auf die gewünschte Anzahl zu reduzieren, jedoch wie kriege ich das jetzt noch bei jedem Array, welches in meinem Array liegt hin? Müsste ich die erstmal in ein normales Array einlesen?boolean[] array //<---- und dieses dann mit Arrays.copyOf(array, counter); reduzieren und anschließend dieses in das größere speichern?
 
T

temi

Also ich schaffe es per Counter die Zeilen auf die gewünschte Anzahl zu reduzieren
Also streng genommen ist diese Aussage ja nicht ganz richtig. Arrays.copyOf() macht einfach nur eine Kopie eines bestehenden Arrays mit einer Länge, die du angibst. In deinem Beispiel: copyOf(int[] original, int newLength)

Was ich damit sagen will ist: Du brauchst ja nichts zu zählen, wenn du sowieso schon weißt, wie groß die Kopie sein soll. Die Aussage lautet also:

"Also ich schaffe es per Arrays.copyOf() das Array auf die gewünschte Größe zu reduzieren/erweitern."

Edit: Was ich wirklich damit sagen will ist: Die Arbeit macht ja nicht Counter ("per Counter") sondern die Methode copyOf().

jedoch wie kriege ich das jetzt noch bei jedem Array, welches in meinem Array liegt hin?
Das hat @mihe7 doch im Beitrag #6 geschrieben:

Das machst Du ja bereits :)
gameboard[0] referenziert unmittelbar im Anschluss an diese Anweisung ein boolean Array der Länge 20. Du kannst das aber zu jeder Zeit ändern: gameboard[0] = new boolean[10]; damit referenziert gameboard[0] ein boolean-Array der Länge 10. gameboard[1] referenziert nach wie vor ein boolean-Array der Länge 20.
boolean [][] gameboard = new boolean[20][20]; erzeugt ein mehrdimensionales Array.

gameboard[0] = Arrays.copyOf(gameboard[0], 10); verkürzt die "erste Reihe" auf eine Länge von 10.
 
Zuletzt bearbeitet:
mihe7

mihe7

Die Sache ist ganz einfach. Gehen wir mal von einem 3x3-int-Array arr aus, dann ergibt sich z. B. folgendes Bild:
Code:
   arr ((int[])[])             int[] b = Arrays.copyOf(arr[0], 2)
          |                                 |
          |            +-----+              |
          |       +->0 |  12 |              |
          |       |    +-----+              v
          |       |  1 |  24 |           +-----+
          |       |    +-----+         0 |  12 |
          |       |  2 |   0 |           +-----+
          |       |    +-----+         1 |  24 |
          v       |                      +-----+
      +-------+  /     +-----+ 
    0 | int[] |--  ->0 |  52 |
      +-------+   /    +-----+
    1 | int[] |---   1 |  81 |
      +-------+        +-----+
    2 | int[] |--    2 |  48 |
      +-------+  \     +-----+
                  |
                  |    +-----+
                  +->0 |  12 |
                       +-----+
                     1 |   0 |
                       +-----+
                     2 |   0 |
                       +-----+
Auf der linken Seite ist das Array arr gezeigt. Die Kästchen stellen Plätze im Hauptspeicher dar. Die Zahl links neben den Kästchen ist der jeweilige Array-Index.

Die Variable arr enthält also die Referenz (im Bild durch Pfeile dargestellt) auf ein Array der Länge 3, dessen Elemente Referenzen auf int-Arrays aufnehmen.

Rechts im Bild sieht man, dass b die Referenz auf das Ergebnis von Arrays.copyOf hält: ein int[]-Array, das nur noch aus zwei Elementen besteht.

Weist man nun arr[0] = b zu, passiert einfach folgendes:

Code:
   arr ((int[])[])             int[] b = Arrays.copyOf(arr[0], 2)
          |                                 |
          |                                 |
          |                                 |
          |                                 v
          |                              +-----+
          |          ----------------> 0 |  12 |
          |         /                    +-----+
          |        /                   1 |  24 |
          v       /                      +-----+
      +-------+  /     +-----+ 
    0 | int[] |--  ->0 |  52 |
      +-------+   /    +-----+
    1 | int[] |---   1 |  81 |
      +-------+        +-----+
    2 | int[] |--    2 |  48 |
      +-------+  \     +-----+
                  |
                  |    +-----+
                  +->0 |  12 |
                       +-----+
                     1 |   0 |
                       +-----+
                     2 |   0 |
                       +-----+
Der Speicher, der zuvor von arr[0] referenziert wurde (Bild oben), wird irgendwann automatisch wieder freigegeben (Garbage Collector).
 
X

Xyz1

o_O Ich erblicke viele mega riesige Schaubilder. mihe7 ist Profi in so etwas...
 
Kirby_Sike

Kirby_Sike

Die Sache ist ganz einfach. Gehen wir mal von einem 3x3-int-Array arr aus, dann ergibt sich z. B. folgendes Bild:
Code:
   arr ((int[])[])             int[] b = Arrays.copyOf(arr[0], 2)
          |                                 |
          |            +-----+              |
          |       +->0 |  12 |              |
          |       |    +-----+              v
          |       |  1 |  24 |           +-----+
          |       |    +-----+         0 |  12 |
          |       |  2 |   0 |           +-----+
          |       |    +-----+         1 |  24 |
          v       |                      +-----+
      +-------+  /     +-----+
    0 | int[] |--  ->0 |  52 |
      +-------+   /    +-----+
    1 | int[] |---   1 |  81 |
      +-------+        +-----+
    2 | int[] |--    2 |  48 |
      +-------+  \     +-----+
                  |
                  |    +-----+
                  +->0 |  12 |
                       +-----+
                     1 |   0 |
                       +-----+
                     2 |   0 |
                       +-----+
Auf der linken Seite ist das Array arr gezeigt. Die Kästchen stellen Plätze im Hauptspeicher dar. Die Zahl links neben den Kästchen ist der jeweilige Array-Index.

Die Variable arr enthält also die Referenz (im Bild durch Pfeile dargestellt) auf ein Array der Länge 3, dessen Elemente Referenzen auf int-Arrays aufnehmen.

Rechts im Bild sieht man, dass b die Referenz auf das Ergebnis von Arrays.copyOf hält: ein int[]-Array, das nur noch aus zwei Elementen besteht.

Weist man nun arr[0] = b zu, passiert einfach folgendes:

Code:
   arr ((int[])[])             int[] b = Arrays.copyOf(arr[0], 2)
          |                                 |
          |                                 |
          |                                 |
          |                                 v
          |                              +-----+
          |          ----------------> 0 |  12 |
          |         /                    +-----+
          |        /                   1 |  24 |
          v       /                      +-----+
      +-------+  /     +-----+
    0 | int[] |--  ->0 |  52 |
      +-------+   /    +-----+
    1 | int[] |---   1 |  81 |
      +-------+        +-----+
    2 | int[] |--    2 |  48 |
      +-------+  \     +-----+
                  |
                  |    +-----+
                  +->0 |  12 |
                       +-----+
                     1 |   0 |
                       +-----+
                     2 |   0 |
                       +-----+
Der Speicher, der zuvor von arr[0] referenziert wurde (Bild oben), wird irgendwann automatisch wieder freigegeben (Garbage Collector).
Ich danke dir für das ausführliche Schaubild :) Jetzt habe ich es endlich verstanden xD
 
Zuletzt bearbeitet:
mihe7

mihe7

Aktuell ist ja das über das Forum steuerbare Elektroschockhalsband an der Reihe - für Leute, die z. B. versuchen, vom Thema abzulenken :p
 
Thema: 

Multidimensionales Array zuschneiden

Passende Stellenanzeigen aus deiner Region:
Anzeige

Neue Themen

Anzeige

Anzeige
Oben