Wie wird ein 2 Dimensionales Array befüllt?

[Loddakwin]

Hallo Leute,

ich hoffe ich bin hier richtig ?
vielleicht ist das jetzt eine blöde frage aber ich kann es einfach nicht nachvollziehen also erhoff ich mir hier eine erklärung.

Also ich habe diesen Code:
[Java]
public class ZweiDimArray {

public static void main (String[] args){


int z = 3; //Anzahl Zeilen
int s = 4; //Anzahl Spalten
int[][] a = new int[z];

for (int zeile = 0; zeile < a.length; zeile++)
for (int spalte = 0; spalte < a[zeile].length; spalte++)
a[zeile][spalte] = zeile + spalte;


for (int zeile = 0; zeile < a.length; zeile++){
for (int spalte = 0; spalte < a[zeile].length; spalte++)
System.out.print(a[zeile][spalte] + " ");
System.out.println();
}

}
}
[/Java]

Ich bin gerade dabei irgendwie herauszufinden wie sich dieses array befüllt ich komm nicht dahinter also in welcher reihenfolge bzw welche schema ?

Schräg nach unten denke ich mal also

0 1 2 3
1 2 3 4
2 3 4 5

aber wo kommt jetzt was in welcher reihenfolge hin ich versteh das einfach nicht ich hoffe man kann mich verstehen

danke im voraus

lg

 

[lordofdonuts]

Hallo Loddakwin,

dafür, dass du nicht weißt in welche Richtung die Schleifen gehen, sind die Variablennamen eigentlich ziemlich gut

Faustregel beim Befüllen Zweidimensionaler Arrays:

Die äußere Schleife ist für die Zeilen zuständig, die innere Schleife für die Spalten.
Das bedeutet, hast du so ein Konstrukt:

for (int zeile = 0; zeile < a.length; zeile++)
{
    for (int spalte = 0; spalte < a[zeile].length; spalte++)
          a[zeile][spalte] = zeile + spalte;
}

kannst du dir das am besten versinnbildlichen, indem du ein Excel-Sheet aufmachst.
Wenn du jetzt einen Wert in die Zelle einfügst und TAB drückst, tust du das, was die innere Schleife macht. Du drückst so oft auf TAB, wie viele Spalten deine Tabelle hat und betätigst ENTER. Somit kommst du in die nächste Zeile, was die äußere Schleife tut.

Der Ablauf wäre von den Indizes her so:

x = Zeile
y = Spalte

  x  y
a[0][0] = 0
a[0][1] = 1
a[0][2] = 2
a[0][3] = 3
a[1][0] = 1
a[1][1] = 2
a[1][2] = 3
a[1][3] = 4
a[2][0] = 2
a[2][1] = 3
a[2][2] = 4
a[2][3] = 5

Tabellenmäßig wie von dir bereits richtig festgestellt

0 1 2 3
1 2 3 4
2 3 4 5

 

[kaoZ]

Wie öfter schon mal erwähnt ist ein Mehrdimensionales Array nichts anderes als ein Array , welches weitere Arrays enthält, du kannst es dir vorstellen wie Schubladen mit Fächern

ein Array der Größe

array[2][2]

hat demnach 2 Schubladen mit jeweils 2 fächern, da Arrays 0-basiert sind also die

 indizies [0][0] + [0][1] und [1][0] + [1][1]

befüllen kannst du dieses wie schon geschrieben über deine verschachtelte For-schleife, die erste Schleife stellt quasi die Schublade dar und die innere zweite Schleife die Fächer.

 

[Loddakwin]

Mag sein das ich wirklich schwer von begriff bin aber das heisst dann das dass array nicht von links nach rechts nach unten arbeitet sondern schräg nach unten stimmt das also die befüllung?

Vielen dank für die ausführliche erklärung

 

[lordofdonuts]

Doch, diese Schleifenverschachtelung arbeitet von links nach rechts nach unten. D.h. es werden alle Spalten befüllt, in die nächste Zeile gesprungen und dann beginnt das Spiel von vorn.

 

[kaoZ]

Stell dir vor das hier ist dein Array der größe [3][3]

[ ] [ ] [ ]
[ ] [ ] [ ]
[ ] [ ] [ ]

das hier ist der index [0][0]

[x] [ ] [ ]
[ ] [ ] [ ]
[ ] [ ] [ ]

für gewöhnlich wenn man eine verschachtelete For-Schleife erstellt begint diese dann bei

 i=0 / j=0

das wäre dann also dieser Punkt

die erste Schleife stellt die

row

(Reihe/Zeile) dar
die Zweite dann die

coloumn

(Spalte)

wie bei einer Tabelle eben.

also wird in

Reihe 0 / Spalte 0

(da Arrays 0-Basiert sind) begonnen zu füllen .

die verschachtelte For Schleife dazu sieht dann so aus

for(int i = 0; i < 3; i++){
  for(int j = 0; j < 3; j++){
     //code 
  }
}

die Schleife wird nun folgendermaßen durchlaufen, bei Schleifeneintritt ist der index

[0][0]

am ende der ersten For Schleife wird nun die zweite ausgeführt. demnach wird diese so oft durchlaufen , bis die Abbruchbedingung der inneren Schleife erfüllt ist , diese wird erreicht wenn

j = 3

.
Wenn dies eintritt, wird erneut die erste Schleife ausgeführt und i um 1 erhöht demnach ist die Position im Array nun

[1][0]

.

Zu diesem Zeitpunkt ist die äußere Schleife 1 mal durchlaufen worden und die innere 3 mal .
Es wurden also folgende indizies abgearbeitet

[0-0] [0-1] [0-2] // first row ( Erste Reihe/Zeile )

und dieses Schema setzt sich fort bist die Abbruchbedingung der äußeren Schleife erreicht wird, welche in diesem Fall ebenfalls

i = 3

ist, da wie auch

j

,

i

immer um

+1

erhöht wird ( wenn das Ende der Schleife erreicht wird ) bis ebend die jeweilige Abbruchbedingung eintritt.


So Sieht der durchlauf im ganzen aus

[0-0] [0-1] [0-2] // ende der inneren Schleife, also i+1
[1-0] [1-1] [1-2] // ende der inneren Schleife, also i+1
[2-0] [2-1] [2-2] // ende der inneren und der äußeren Schleife da i | j jeweils = 3

 

[Loddakwin]

Danke ich habe es jetzt voll und ganz verstanden sry das ich mich so dumm angestellt habe!