2 dimensionales Array befüllen

J

Javaman91

Bekanntes Mitglied
Hallo zusammen,

ich habe diesen Code hier im Forum gefunden:

Java: 
        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]
 
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.
 
Ach so.

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

Java: 
a[i][j]=i;

Er übergibt "i" dem Array, warum?
 
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 ;-)
 
Zuletzt bearbeitet von einem Moderator:
Mit diesem code:

Java: 
a[i][j]=i;

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

Wenn ich das so schreibe:

Java: 
a[i][j];

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

MfG
 
Elenteria hat gesagt.:
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.
Zum Vergrößern anklicken....
Das stimmt zwar, allerdings hätte es auch funktioniert, wenn j bereits ausserhalb der Schleife deklariert worden wäre:
Java: 
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.
 
Und wie befüllt man nun ein 2 dimensionales Array?

Einfach indem ich sage:

Java: 
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?
 
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.
 
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.
 
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....
 
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.
 
Javaman91 hat gesagt.:
Und wie befüllt man nun ein 2 dimensionales Array?
Zum Vergrößern anklicken....
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
Javaman91 hat gesagt.:
Dies kann aber nicht funktionieren.
Zum Vergrößern anklicken....
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:
Java: 
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
  }
}
 
Hier habe ich mal eine Zeile aus einer Text-Datei ausgelesen.

Java: 
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?
 
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):
Java: 
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?
Javaman91 hat gesagt.:
Ich möchte aber nicht für jede Zeile im Text ein eigenes "readLine()" ansetzen?
Zum Vergrößern anklicken....
Was hat dieses statement mit Arrays zu tun?
 
Javaman91 hat gesagt.:
Anstatt solle Fragen zu stellen, wäre es vielleicht produktiver mir bei meinem verständnis Problem zu Helfen.
Zum Vergrößern anklicken....

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?

Javaman91 hat gesagt.:
Ich kann mich auch nur Schritt für Schritt nach vorne arbeiten.
Zum Vergrößern anklicken....

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

Javaman91 hat gesagt.:
Wo ich nicht mehr weiter komme kann ich auch nur nachfragen.
Wer nicht Fragt, wird auch nie weiter kommen.
Zum Vergrößern anklicken....

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.
 
Javaman91 hat gesagt.:
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?
Zum Vergrößern anklicken....

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!
Java: 
// 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 hat gesagt.:
Ich habe nur gefragt, und nichts "abqualifizierst".
Zum Vergrößern anklicken....
In deinem ersten Beitrag, aus dem ich zitiert habe, hast du keine Frage zu dem geposteten Code gestellt, sondern ihn mit
Javaman91 hat gesagt.:
Dies kann aber nicht funktionieren
Zum Vergrößern anklicken....
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.
 
Danke für den Link.

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

Java: 
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:

Java: 
!= 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!!
 
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.
 
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!
 
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();".

Java: 
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?
 
Zuletzt bearbeitet von einem Moderator:
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 😉).
 
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 ?
 
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:

Java: 
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];
           }
         }
       }

??
 
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:

Java: 
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
 
Java: 
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);
           }
          }
         }
        }
       }
      }
 
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.
 
Javaman91 hat gesagt.:
array[y][x]
Zum Vergrößern anklicken....
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 !
 
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 !
 
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.
 
Was ist denn die aktuelle Frage? Was möchtest du machen?

Wenn's noch um Array befüllen geht, das ist ganz lustig:
Java: 
        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.
 
Javaman91 hat gesagt.:
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.
Zum Vergrößern anklicken....
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
Java: 
if(array[x][y] == 'h'){
zu
Java: 
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.
 
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:

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

Nachdem ich x und y umgedreht habe funktioniert es:

Java: 
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.
 
Zuletzt bearbeitet:

Aktuelle Jobs

Neue Themen

Ähnliche Themen

3-dimensionales Array in 1-dimensionales umwandeln
Antworten: 10
2 dimensionales Array eleganter befüllen
Antworten: 2
1-Dimensionales Array in 2D Array umwandeln
Antworten: 5
2-Dimensionales Array in Eindimensionales Array
Antworten: 1
2-dimensionales Array
Antworten: 2

Zurück
Oben