2 dimensionales Array befüllen

[Javaman91]

Hallo zusammen,

ich habe diesen Code hier im Forum gefunden:

        int[][] a;                 
        a=new int [3][3];
       
        for(int i=0; i<a.length;i++){
            for(int j=0; j<a.length; j++){
                a[i][j]=i;
         }
        }

Dies kann aber nicht funktionieren.

Hier wird ja zuerst die erste For-Schleife einmal durchlaufen, dann wird die innere For-Schleife 3-Mal durchlaufen, da "j" nach dem 3 durchlauf gleich "a" ist.
Nun wird wieder die erste For-Schleife aufgerufen und einmal durchlaufen.
Danach sollte wieder die innere Schleife 3-Mal durchlaufen werden.
Das kann Sie aber garnicht, da die Variable "j" ja noch immer 3 ist und nicht 0.

Man müsste ja nach dem durchlauf der inneren Schleife "j" auf 0 setzen??[/code]

 

[Thallius]

Was meinst du denn wohl was

for(int j=0; ...

genau macht?

Gruß

Claus

 

[Elenteria]

Variablen sind nur innerhalb des Blocks gültig in denen sie Deklariert wurden. nach verlassen des Blocks werden sie wieder verworfen. Eine For-Schleife ist ein solcher Block. i und j werden im Schleifenkopf deklariert und initalisiert und sind deshalb nur innerhalb der schleife vorhanden.
Mit anderen Worten nach verlassen der inneren Schleife wird j weggeschmissen und beim nächsten Durchlauf der äußeren Schleife wird ein neues frisches j erstellt mit dem Wert 0.

 

[Javaman91]

Ach so.

nun muss ich euch noch fragen, was diese Zeile bedeuten soll:

a[i][j]=i;

Er übergibt "i" dem Array, warum?

 

[Elenteria]

Technisch wird hier der Wert der in i steht, also 0,1,oder 2 in die position [i][j] des Arrays a geschrieben. Also eine Simple Variablen zuweisung. Aber was die Beweggründe waren das zu tun kann, dir ohne Kontext nur der Ursprüngliche Author des Codes sagen ;-)

 

[Javaman91]

Mit diesem code:

a[i][j]=i;

wird ja das gesamte Array nur mit "i" befüllt.

Wenn ich das so schreibe:

a[i][j];

dann wird das Array mit "i" und "j" befüllt.

MfG

 

[Thallius]

nein so wird es gar nicht befüllt.

 

[InfectedBytes]

a[i][j];

dann wird das Array mit "i" und "j" befüllt.

MfG

Das ist nichtmals gültiger Code

 

[Meniskusschaden]

Mit anderen Worten nach verlassen der inneren Schleife wird j weggeschmissen und beim nächsten Durchlauf der äußeren Schleife wird ein neues frisches j erstellt mit dem Wert 0.

Das stimmt zwar, allerdings hätte es auch funktioniert, wenn j bereits ausserhalb der Schleife deklariert worden wäre:

int[][] a;              
a=new int [3][3];

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

Die Initialisierung findet beim Betreten der Schleife statt, unabhängig davon, ob die Variable dann erst deklariert wird oder bereits vorher deklariert wurde. Die innere Schleife wird hier drei Mal betreten, dementsprechend wird auch der Initialisierungsteil der Schleife drei Mal ausgeführt.

 

[Javaman91]

Und wie befüllt man nun ein 2 dimensionales Array?

Einfach indem ich sage:

a[0][0] = 10; 
a[1][2] = 30;

Wenn ich sage "a[0][0] = 10;", dann hat das Feld an der Position 0,0 den Wert; 10.
An der Position 1,2 den Wert: 30 usw?

 

[InfectedBytes]

wenn du jeden einzelnen Wert manuell eintragen willst ja.
Aber jenachdem welche Werte da rein sollen, macht es eben mehr Sinn das ganze mit einer Schleife zu machen.
Vielleicht solltest du mal schreiben, was denn später in deinem 2D array drin stehen soll.

 

[Javaman91]

Ich bin gerade dabei eine Map für ein kleines Game zu erstellen.
Dies wollte ich mit einem Level-Editor machen.
Ich habe mir ein Tutorial angesehen, leider erklärt der Typ den Code für einen Anfänger zu wenig.
Deshalb arbeite ich mich Schritt für Schritt selbst voran.
Nun wollte ich einfach einzelne Char-Zeichen aus der Datei auslesen und in ein Array schreiben.
Ich weiß, das man das mit einer For-Schleife machen sollte, habe aber keine Ahnung wie ich die Daten in das Array bekomme.
Habe gerade eben versucht eine Text-Datei einzulesen, doch bekomme ständig eine Fehlermeldung.
Die Fehlermeldung habe ich gerade in einem neuen Thread hochgeladen.

 

[T_T]

Mal ne kleine Frage, meinst du, du bist schon soweit für Mehrdimensionale Arrays? Mir scheint es fast so, als stündest du noch ganz am Anfang von Java....

 

[Javaman91]

Nur weil ich etwas noch nicht ganz durchblickt habe heißt das nicht, dass ich nicht weiß wie Arrays aufgebaut sind.

Anstatt solle Fragen zu stellen, wäre es vielleicht produktiver mir bei meinem verständnis Problem zu Helfen.

Ich kann mich auch nur Schritt für Schritt nach vorne arbeiten.
Bin leider nicht als Java-Programmierer vom Himmel gefallen.
Wo ich nicht mehr weiter komme kann ich auch nur nachfragen.
Wer nicht Fragt, wird auch nie weiter kommen.

 

[Harry Kane]

Und wie befüllt man nun ein 2 dimensionales Array?

Falls das immern noch deine Frage ist: Die Antwort steht in deinem ersten Beitrag. Vielleicht hättest du überprüfen sollen, ob der Code das tut was er soll, bevor du ihn mit

Dies kann aber nicht funktionieren.

abqualifizierst.
Einen Schönheitsfehler hat das ganze aber noch. Ein int[][] ist ja ein Array (nenen wir es mal das "äußere" Array) von int-Arrays (nennen wir sie mal die "inneren Arrays"). Der Code wird nur funktionieren, wenn jedes der inneren int-Arrays maximal so lang ist wie das äußere Array.
Fehlersicherer ist folgende Variante:

int[][] a = new int [3][3];   
for(int i=0; i<a.length;i++){
  for(int j=0; j<a[i].length; j++){
  a[i][j]=(i+1)*(j+1);// für eine tabelle mit dem kleinen 1x1
  }
}

 

[Javaman91]

Hier habe ich mal eine Zeile aus einer Text-Datei ausgelesen.

package map;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;


public class Fenster {
   
   public static void main(String[] args) throws IOException {
     
     FileReader filereader = new FileReader("map1.txt");
     BufferedReader br = new BufferedReader(filereader);
     
     String temp = br.readLine();
     
     char array[][] = new char[5][5];
     
     char tempArray[] = temp.toCharArray();
     
     for(int i=0; i < array.length; i++){
       for(int j =0; j < array.length; j++){
         
         array[i][j] = tempArray[j];
       }
     }
     
     for(int x=0; x<array.length; x++){
       for(int z=0; z<array.length; z++){
         
         System.out.println(array[x][z]);
       }
     }
     
   }
}

Nun wollte ich aber, dass das gesamte Text-File in das Array gespeichert wird.
Ich möchte aber nicht für jede Zeile im Text ein eigenes "readLine()" ansetzen?

 

[Harry Kane]

Das wird nur ohne Fehler funktionieren, wenn temp mindestens 5 characters lang ist.
Und nehmen wir mal an, "temp" wäre "foobar", wäre der Inhalt von array folgendes (wenn man das zweidimensionale Array als Tabelle ansieht, was es streng genommen natürlich nicht ist):

f f f f f
o o o o o
o o o o o
b b b b b
a a a a a
oder
f o o b a
f o o b a
f o o b a
f o o b a
f o o b a

Was bringt dir das?

Ich möchte aber nicht für jede Zeile im Text ein eigenes "readLine()" ansetzen?

Was hat dieses statement mit Arrays zu tun?

 

[T_T]

Anstatt solle Fragen zu stellen, wäre es vielleicht produktiver mir bei meinem verständnis Problem zu Helfen.

Meine Antwort soll keineswegs ein Angriff oder ähnliches darstellen. Ich habe lediglich eine Frage in den Raum gestellt die durchaus wichtig erscheint.

Wie willst du ein Haus bauen ohne das richtige Fundament?

Ich kann mich auch nur Schritt für Schritt nach vorne arbeiten.

Das muss jeder. Es gibt wunderbare Literaturen, die verständlich alle Grundlagen der Programmierung aufzeigen.

Wo ich nicht mehr weiter komme kann ich auch nur nachfragen.
Wer nicht Fragt, wird auch nie weiter kommen.

Stimme ich dir 100% zu. Aber gleichzeitig sollte man sich die Frage stellen ob man lieber mehrere kleine oder einen Großen Schritt geht und ggf. auf die "Schnauze" fliegt.

 

[Joose]

Nun wollte ich aber, dass das gesamte Text-File in das Array gespeichert wird.
Ich möchte aber nicht für jede Zeile im Text ein eigenes "readLine()" ansetzen?

Musst du auch nicht. Eine Schleife die solange readLine() aufruft bis du eben die ganze Datei gelesen hast reicht.
Hier ein Beispiel: http://www.mkyong.com/java/how-to-read-file-from-java-bufferedreader-example/

Zu deinem Code noch eine Anmerkung:
Schreibe nicht die [] hinter den Namen der Variable sondern hinter den Typ!

// SO NICHT!
char array[][] = new char[5][5];
char tempArray[] = temp.toCharArray();
......
// SONDERN SO ;)
char[][] array = new char[5][5];
char[] tempArray = temp.toCharArray();

Der Java Compiler beschwert sich zwar nicht, aber so trennst du die Typ Information auf 2 Teile auf. So ist nicht immer auf einen Blick ersichtlich das es sich um ein Array handelt.

 

[Javaman91]

Ich habe nur gefragt, und nichts "abqualifizierst".

 

[Harry Kane]

Ich habe nur gefragt, und nichts "abqualifizierst".

In deinem ersten Beitrag, aus dem ich zitiert habe, hast du keine Frage zu dem geposteten Code gestellt, sondern ihn mit

Dies kann aber nicht funktionieren

bewertet. Da der Code trotz des von mir beschriebenen Schönheitsfehler funktioniert, habe ich mir gestattet, dein verwendetes wording als "abqualifizieren" zu bezeichnen.
Gerade als Anfänger (nicht nur im Programmieren) tun man gut daran, etwas zunächst zu testen, bevor man es in die Kategorien "geht" oder "geht nicht" einsortiert.

 

[Thallius]

Der Java Compiler beschwert sich zwar nicht, aber so trennst du die Typ Information auf 2 Teile auf. So ist nicht immer auf einen Blick ersichtlich das es sich um ein Array handelt.

Streng genommen richtig aber als alter "C-Hase" finde ich die Schreibweise immer wieder häßlich

Gruß

Claus

 

[Javaman91]

Danke für den Link.

Wusste bis jetzt nicht, das man im Schleifenkopf ein "sCurrentLine = br.readLine()" machen kann:

while ((sCurrentLine = br.readLine()) != null){
}

Ich hätte das for der While-Schleife gemacht.

Dies sind genau die Feinheiten wo ich oft Probleme habe, da dies in den Quellen nie erklärt wird. Es wird in den weiteren Kapiteln einfach durchgeführt. Und ich frage mich dann, was machen die da und das Verwirrt mich leider sehr oft.

Nun aber eine Frage, was passiert hier:

!= null

"null" verwende ich immer, wenn ich eine lokale Variable initialisiere.
Was Java ja bei lokalen Variablen nicht automatisch macht.

Was passiert, wenn er "ungleich null" abfragt?

MfG und DANKE für die Hilfe!!

 

[InfectedBytes]

Es wird eben geprüft, ob etwas ungleich null ist.
Objektvariablen zeigen entweder auf ein konkretes Objekt oder eben auf null (quasi auf "nichts")

Die Schleife wird also nur solange ausgeführt, wie sCurrentLine auf tatsächlich auf einen String zeigt.
Wenn der BufferedReader am Ende der Datei angekommen ist, gibt er nur null zurück.

 

[Javaman91]

Achso, mit "null" wird einfach überprüft ob das Ende vom Text-File erreicht wurde.
Das heißt, wenn das Ende des Text-Files noch nicht erreicht wurde hat die Variable "sCurrentLine" nicht "null" sondern z.B. einen Text wie "hallo" gespeichert.
Daurch ist die Bedingung in der While-Schleife noch erfüllt und es wird im Text weiter gelesen.

Super, danke!

 

[Javaman91]

Muss euch gleich noch was Fragen.

In der While-Schleife befülle ich ein temporäres Array mit den Daten vom Text-File.
Um genau zu sein, splitte ich den String in einzelne "char" Zeichen auf und schreibe diese dann ins temporäre Array hinein: "char tempArray[] = temp.toCharArray();".

public static void main(String[] args) throws IOException{
   
     Fenster fenster = new Fenster();
     FileReader filereader = new FileReader("map1.txt");
     BufferedReader br = new BufferedReader(filereader);
       
     while((temp = br.readLine()) != null){
   
       char tempArray[] = temp.toCharArray();
      }
   
       for(int i=0; i < array.length; i++){
         for(int j =0; j < array.length; j++){
       
           array[i][j] = tempArray[j];
         }
        }
       }

Anschließend habe ich zwei For-Schleifen um ein zweidimensionales Array zu befüllen.
Ung ganeu hier habe ich das problem, das ich nicht auf das temporäre Array zugreifen kann:
array[j] = tempArray[j];"
Ich kann nur drauf zu greifen, wenn ich die zwei For-Shleifen in der While-Schleife habe.
Ausserhalb der While-Schleife geht nix mehr.

Wie könnte ich drauf zu greifen?

 

[Joose]

Das Problem: tempArray wird in der while-Schleife deklariert. Daher ist es eben nur innerhalb der while-Schleife bekannt und du kannst nicht von außerhalb darauf zugreifen (Scope: http://www.java-made-easy.com/variable-scope.html)

Mögliche Lösung: Lasse die while-Schleife weg und verwende stattdessen temp = brd.readLine() innerhalb der for-Schleife (welche musst du rausfinden ).

 

[Elenteria]

Variablen sind nur innerhalb des Blocks gültig in denen sie Deklariert wurden. nach verlassen des Blocks werden sie wieder verworfen.

tempArray[] ist außerhalb deiner while-Schleife nicht bekannt, entsprechend kann nicht darauf zugegriffen werden.

 

[Javaman91]

Kann ich das temporäre Array nicht irgendwie für die gesamte Main-Methode sichtbar machen?

 

[JStein52]

Ja klar. Mach doch mal. Wo gehört das dann wohl hin ? Du hast doch andere Variablen auch die in main sichtbar sind

Edit: ein Tipp, deine While-Schleife ist ein bisschen zu kurz geraten ! Überleg mal wo da die schliessende Klammer hin gehört ?

 

[Javaman91]

Mein Level-Editor funktioniert wunderbar, bis auf eine kleinigkeit.
Wenn ich in der Datei z.B. folgendes festlege:

hhhhhhhhhh
bbbbbbbbbb
aaaaaaaaaa

dann sollte er für "h" ein rotes Rechteck zeichnen.
Für "b" ein schwarzes usw.

Nun zeichnet er aber das ganze nicht waagerecht -> hhhhhhhhhh sonder senkrecht, also von oben nach unten.
Er soll es aber eben waagerecht Zeichnen genau wie in der Datei angegeben, also von Links nach Rechts.
Ich komme nicht dahinter warum.

Hier der code:

public static void main(String[] args) throws IOException{
    
     Fenster fenster = new Fenster();
     FileReader filereader = new FileReader("map1.txt");
     BufferedReader br = new BufferedReader(filereader);
    
     for(int i=0; i < array.length; i++){
      
       temp = br.readLine();
       char tempArray[] = temp.toCharArray();
            
         for(int j=0; j < array.length; j++){
            
             array[i][j] = tempArray[j];
           }
         }
       }

??

 

[InfectedBytes]

guck mal auf die Koordinaten (array[i][j]) von deinem Array. Sowohl beim einlesen, als auch beim zeichnen

 

[JStein52]

Dieser Code zeichnet gar nichts. Weder rot noch grün, weder waagrecht noch senkrecht ? Wie soll man denn diese Frage beantworten ?

 

[Javaman91]

Ja, das umdrehen von "i" & "j" beim Zeichnen des Arrays hat funktioniert.
Dort wo das Array befüllt wird, habe ich nichts geändert.

Aber wieso??

Ich befülle das Array doch mit:

for(int i=0; i < array.length; i++){
       
       temp = br.readLine();
       char tempArray[] = temp.toCharArray();
             
         for(int j=0; j < array.length; j++){
             
             array[i][j] = tempArray[j];
           }
         }
       }

Das Array ist doch folgendermaßen aufgebaut:

Hinweis: die zwei Klammern "[]" sollen ein Feld des Arrays darstellen.

[0,0][0,1][0,2][0,3]...
[1,0][1,1][1,2][1,2]...
....

"i" ist am anfang 0, dann bin ich in der ersten Zeile.
Anschließend wird die Schleife mit "j" 10 mal ausgeführt.
Dadurch wird die erste Zeile des Arrays mit Daten befüllt:

[][][][][][][][][][] <- (i = 0, j = 1,2,3...usw.)
[][][][][][][][][][]
....

Danach erhöht sich "i" zu 1 und "j" befüllt nun die zweite Zeile:

[][][][][][][][][][]
[][][][][][][][][][] <- (i = 1, j = 1,2,3...usw.)
....

Beim auslesen gehe ich ja genau gleich vor.
Wiese muss ich dann "i" & "j" umdrehen?

MfG

 

[InfectedBytes]

weil du wahrscheinlich eben nicht gleich vorgehst...aber ohne den entsprechenden Code zu sehen, kann man dir nicht helfen

 

[Javaman91]

public static void main(String[] args) throws IOException{
    
     Fenster fenster = new Fenster();
     FileReader filereader = new FileReader("map1.txt");
     BufferedReader br = new BufferedReader(filereader);
    
     for(int i=0; i < array.length; i++){
      
       temp = br.readLine();
       char tempArray[] = temp.toCharArray();
            
         for(int j=0; j < array.length; j++){
            
             array[i][j] = tempArray[j];
             System.out.println(array[i][j]);
           }
         }
       }

   public class Zeichne extends JPanel{
    
     public Zeichne(){
    
       this.setSize(500, 500);
     }
    
     public void paint (Graphics g){
      
       for(int x=0; x<10; x++){
         for(int y=0; y<10; y++){
      
           if(array[y][x] == 'h'){ 
            
             g.setColor(Color.pink);
             g.fillRect(x*50, y*50, 50, 50);
           }
      
           else if(array[y][x] == 'l'){ 
            
             g.setColor(Color.white);
             g.fillRect(x*50, y*50, 50, 50);
           }
      
           else if(array[y][x] == 'g'){ 
            
             g.setColor(Color.GREEN);
             g.fillRect(x*50, y*50, 50, 50);
           }
      
           else if(array[y][x] == 'b'){ 
            
             g.setColor(Color.black);
             g.fillRect(x*50, y*50, 50, 50);
           }
          }
         }
        }
       }
      }

 

[Meniskusschaden]

Die Laufvariable der äußeren Schleife repräsentiert in beiden Fällen die Zeilennummer (i und x), die der inneren Schleife die Spaltennummer (j und y). Die Namen x und y sind also verdreht. Ich würde sie ohnehin lieber zeile und spalte nennen, denn in deinem Programm repräsentieren sie keine xy-Koordinaten und verwirren deshalb nur.

 

[JStein52]

array[y][x]

Irgendwas musst du dir doch dabei gedacht haben beim Zeichnen plötzlich die Indizes umzudrehen ? Was denn ?

Edit: Und wieso laufen deine Schleifen beim Zeichnen denn immer bis 10 ? Schreibe doch mal nur jeweils drei Buchstaben in eine Zeile dann wirds wahrscheinlich das nächste Mal krachen (es sei denn du hast dein Array wirklich 10x10 gemacht und mit irgendwas initialisiert. Auf jeden Fall passt einlesen und zeichnen nicht zusammen !

 

[JStein52]

Und der Vollständigkeit halber: Deine Schleifen beim Einlesen der Datei sind genauso Mist. Die gehen alle beide bis array.length, was ist wenn in der Datei weniger drin steht ? Beendest du dann das Einlesen über eine Exception ? Das ist Unsinn. du hast dir doch weiter oben zeigen lassen wie man bis zum Ende einer Datei enliest. Warum machst du es nicht so ? Und wenn in einer Zeile weniger Zeichen stehen als dein Array Zeile hat fliegt eine IndexOutOfBoundsException !

 

[Javaman91]

JStein52 kannst du mal was Sinnvolles sagen oder nur ablästern wie Sch***e mein Code ist????
Ich bin gerade dabei es zu lernen, falls Du das noch nicht mitbekommen hast!

Ich habe mich jetzt einmal auf ein Array mit 10*10 festgelegt, da dieses Programm nur zum probieren dient.

Ich habe gefragt, warum ich die Koordinaten vertauschen soll.
Das leuchtet mir einfach nicht ein, ich habe oben weiter erklärt wie ein Array befüllt wird.
Warum ich das jetzt vertauschen sollte verstehe ich nicht.
Nur so vergeht mir langsam aber sicher die Motivation.

Das ich bei diesem Program eine "IndexOutOfBoundsException" bekomme, wenn ich die Datei von der Anzahl her ändern sollte weiß ich selber!!
Um das geht es aber gerade nicht, vielleicht solltest du mal meine Frage lesen bevor du irgendetwas schreibst.

 

[JStein52]

Ich habe gefragt, warum ich die Koordinaten vertauschen soll.

Mhmmm, und ich habe dich gefragt warum du vom oberen Teil des Codes (wo du ja zeilen und Spalten noch richtig hattest) plötzlich im unteren Teil Zeilen und Spalten umdrehst. Du hast doch einfach mal so zeilen und Spalten umgekehrt. Warum denn ?

 

[Xyz1]

Was ist denn die aktuelle Frage? Was möchtest du machen?

Wenn's noch um Array befüllen geht, das ist ganz lustig:

        Random r = new Random();
        int[][] multiDim = new int[r.nextInt(10)][];
        for (int i = 0; i < multiDim.length; i++) {
            multiDim[i] = new int[r.nextInt(10)];
            for (int j = 0; j < multiDim[i].length; j++) {
                multiDim[i][j] = r.nextInt(10);
            }
        }
        System.out.println("Arrays.deepToString(multiDim) = " + Arrays.deepToString(multiDim));

Arrays.deepToString(multiDim) = [[x], [x, x, x], [x, x, x, x], [x], [x], [x], [x, x, x, x, x, x, x, x, x], [x, x, x, x, x], [x, x, x, x, x]]

In anderen Programmiersprachen nicht so einfach zu erreichen.

 

[Meniskusschaden]

Ich habe gefragt, warum ich die Koordinaten vertauschen soll.
Das leuchtet mir einfach nicht ein, ich habe oben weiter erklärt wie ein Array befüllt wird.
Warum ich das jetzt vertauschen sollte verstehe ich nicht.

Du sollst es gar nicht vertauschen. Du hast es aber vertauscht und zur Korrektur an anderer Stelle ein zweites Mal vertauscht. Deine äußere Schleife der Eingabe benutzt i für die Zeilen, deine äußere Schleife der Ausgabe benutzt x für die Zeilen. Das ist die erste, vermutlich unbewußte Vertauschung, denn den Variablennamen x würde man normalerweise für die horizontale Position verwenden, also die Spalten. Um das zu korrigieren, könntest du in der äußeren Schleife y und in der inneren Schleife x benutzen. Dein erster Ausgabecode liegt uns nicht vor, aber wahrscheinlich hast du

if(array[x][y] == 'h'){

zu

if(array[y][x] == 'h'){

geändert und damit eine zweite Vertauschung vorgenommen, die die erste kompensiert.

Warum nimmst du nicht einfach identische Variablennamen zum Einlesen und Ausgeben. Dann siehst du sofort, dass du die Schleifen für Ein- und Ausgabe identisch aufbauen kannst. Wie bereits geschrieben würde ich dann aber bessere Namen verwenden, damit man direkt sieht, wofür sie gedacht sind.

 

[Javaman91]

Ja genau, ich habe genau das gemacht was Meniskusschaden geschrieben hat.
Nachdem ich das gemacht habe hat das Programm funktioniert, davor wurde alles falsch gezeichnet.
Ich habe einfach mal herumprobiert, da ich nicht mehr weiter wusste.
Deshalb habe ich das gemacht.

Nun weiß ich, woran es lag.
Keine Ahnung, warum ich erst jetzt drauf gekommen bin.

Der Fehler lag beim Zeichnen des Rechteckes.
Hier hatte ich am Anfang:

g.fillRect(x*50, y*50, 50, 50);

Nachdem ich x und y umgedreht habe funktioniert es:

g.fillRect(y*50, x*50, 50, 50);

Ich wollte die Koordinaten von "array[x][y]" nicht vertauschen.
Ich weiß ja mittlerweile wie man ein Array befüllt.
Ich hab dann halt einfach herumprobiert, da ich nicht mehr weiter wusste und habe dann halt "x & y" vertausch obwohl das eigentlich Falsch ist.
Es hat aber dann funktioniert.

Naja, nun weiß ich das der erste Code den ich geschrieben habe korrekt war.
Es lag nicht an x & y im Array sondern an x & y von fillRect.