ArrayIndexOutOfBoundsException

susi1600

Neues Mitglied
Hallo,

ich darf nun in meinem Studium Java lernen, natürlich bekommen wir auch Aufgaben gestellt, die zu lösen sind. Nun habe ich ein Problem mit folgender Aufgabe:

Zu erstellen ist ein Labyrinth als Char-Array mit 10x10 Feldern, ein Leerzeichen bedeutet Weg, ein X bedeutet Wand.
Startpunkt (S) ist die Mitte des Labyrinths. Nun soll rekursiv ein Ausweg an den Rand des Labyrinths gefunden werden, und der mögliche Weg soll am Ende mit Sternchen ausgegeben werden, etwa so:

Java:
Es wurde ein Ausweg gefunden!
 X X XXXXX
XXX   XX X
XXXX X  XX
XXXX    X
 X**S  
 **    X
X*     X
X*  XX   
X* XXXX  X
 *X X X  X

Nun bin ich schon soweit, dass ich meinen Weg ausgegeben bekomme, erstellt mein Random-Labyrinth-Generator jedoch ein Labyrinth ohne Ausweg, erhalte ich die Fehlermeldung : ArrayIndexOutOfBoundsException: -1 und ich verstehe nicht wieso.

Hier mein Code:

Java:
public class Labyrinth {

    public static void main(String[] args) {
        
        char[][] labyrinth = new char[10][10];
        for( int i = 0; i < labyrinth.length; i++ ) {
            for( int j = 0; j < labyrinth[i].length; j++ ) {
                if(java.lang.Math.random() > 0.4 ) {
                    // blockiert
                    labyrinth[i][j] = 'X';
                } 
                else {
                    // frei
                    labyrinth[i][j] = ' ';
                }
            }
        }
        
        // Mitte/Startpunkt errechnen
        int horizontaleMitte = (labyrinth.length -1 ) / 2;
        int vertikaleMitte   = (labyrinth[0].length -1 ) / 2;       
        
        //Startpunkt
        labyrinth[horizontaleMitte][vertikaleMitte] = 'S';
        
        labyrinthAusgeben(labyrinth);
        
        boolean ende = wegFinden(labyrinth , horizontaleMitte, vertikaleMitte);

        if(ende){
            System.out.println("Es wurde ein Ausweg gefunden!");
            labyrinthAusgeben(labyrinth);
        }
        else{
            System.out.println("Es wurde kein Ausweg gefunden!");
        }      

    }
    
    public static boolean wegFinden(char [][] labyrinth, int i, int j){
        boolean wegGefunden = true;
        
        int nachRechts = j+1;
        int nachLinks  = j-1;     
        int nachUnten = i+1;
        int nachOben = i-1;
        
        if(i == labyrinth.length-1 || j == labyrinth[0].length-1){
            return wegGefunden;
        }
   
        else {
            if (labyrinth[i][nachRechts] == 'X'){
                labyrinth[i][nachRechts] = 2;
                if(wegFinden(labyrinth,i,nachRechts)) {
                    labyrinth[i][nachRechts] = '*';
                    return true;
                }
            }
            if (labyrinth[nachUnten][j] == 'X'){
                labyrinth[nachUnten][j]=2;
                if(wegFinden(labyrinth,nachUnten,j)) {
                    labyrinth[nachUnten][j] = '*';
                    return true;
                }
            }
            if (labyrinth[i][nachLinks] == 'X'){
                labyrinth[i][nachLinks]=2;
                if(wegFinden(labyrinth,i,nachLinks)) {
                    labyrinth[i][nachLinks] = '*';
                    return true;
                }
            }
            if (labyrinth[nachOben][j] == 'X'){
                labyrinth[nachOben][j]=2;
                if(wegFinden(labyrinth,nachOben,j)) {
                    labyrinth[nachOben][j] = '*';
                    return true;
                }
            }
        }
        
        return false;
    }

   /*
   * Ausgabe des gesamten Feldes auf dem Bildschirm
   */
	public static void labyrinthAusgeben( char[][] labyrinth ) {
        for( int i = 0; i < labyrinth.length; i++ ) {
            for( int j = 0; j < labyrinth[i].length; j++ ) {
                System.out.print( labyrinth[i][j] );
            }
            System.out.println();
        }
    }
    
}

Ich weiß, dass der Index eines Array bei 0 beginnt, heißt, mein Labyrinth-Array hat eigentlich 11 Stellen und nicht 10. Aber egal wie ich es drehe, ich komm nicht auf die Lösung, weil ich einfach nicht verstehe, was logisch gesehen schief läuft.

Vielleicht kann mir jemand Hilfe-Stellung geben?
Danke schon vorab und viele Grüße,

Susi
 
Zuletzt bearbeitet von einem Moderator:
zb
int[] array = int[10];
nein das array hat 10 stellen, du greifst mit 0 auf die erste zu, mit 9 auf die zehnte mit,
10 auf die elte... crash out of bounds du hast nur 10...
 
Irgendwie sehe ich hier keine Schleife bei der Wegsuche. Bist Du sicher, dass das der aktuelle Code mit dem Fehler ist?

Die Ursache liegt aber wahrscheinlich hier [JAVA=48]if(i == labyrinth.length-1 || j == labyrinth[0].length-1){
return wegGefunden;
}[/code]Du prüfst nur 2 Seiten des Labyrinths (dass streng genommen ein Irrgarten ist...), es hat aber 4.


[EDIT]
zb
int[] array = int[10];
nein das array hat 10 stellen, du greifst mit 0 auf die erste zu, mit 9 auf die zehnte
Ja.
mit,
10 auf die elte... crash out of bounds du hast nur 10...
Aha, daher
Code:
ArrayIndexOutOfBoundsException: [B]-1[/B]
?[/EDIT]

bye
TT
 
Zuletzt bearbeitet von einem Moderator:
Also leider bin ich jetzt immer noch nicht schlauer.
Manchmal klappt das Script, manchmal nicht.

Ein solches Labyrinth erzeugt das Problem:
Java:
XX XXX XXX
X X X   XX
 XX X X X 
 XX X X  X
XXXXSX X  
 X X   XXX
X  X   X X
X   X X X 
X   XXX XX
X X XX X X

Meldet einmal den Fehler hier:
if (labyrinth[i][nachLinks] == 'X')

und 4x in Folge den Fehler zwei Zeilen weiter hier:
if(wegFinden(labyrinth,i,nachLinks))

Bei folgendem Labyrinth gibt das Script aus, es wäre kein Ausweg gefunden worden:
Java:
XX  X XXX 
X    XXXX 
 X   X XX 
 X  X XXX 
 X  S   XX
 X X   X X
X X  XXX X
XXX  XX X 
XX XXXXXXX
 XXX  X XX

Dabei gehts doch nach oben weg ?!
 
Zufallslabyrinthe können ganz hilfreich sein, hier sind sie aber schlecht, niemand kann gut deine Beispiele direkt nachvollziehen,
gut, per Zufall dürfte man auch wieder schnell auf Problemfälle stoßen, die sind aber auch schlecht zu debuggen wenn danach wieder weg,

sobald du einen Fehlerfall gefunden hast, solltest du diesen festeinprogrammieren, Mauer für Mauer vorgeben,
damit wiederholt zu untersuchen

eine Zwischenlösung kann ein Random-Objekt mit einem bestimmten Seed/ Startwert im Konstruktor statt Math.random() sein,
das liefert immer dieselben Zufallswerte, Umschalten bei Tests dann etwas aufwendiger,
helfen könnte wiederum den Seed zufällig wählen zu lassen und mit auszugeben, im interessanten Fall aufzuschreiben,
na wie auch immer

weiterhin hilfreich ist, am Anfang möglichst klein zu starten, z.B. 4x4 Felder, oder klappt dort wiederholt alles?

sofern ein festes Beispiel gefunden ist, gilt es genau die Schritte zu untersuchen,
kann jetzt grad nicht mehr schreiben
 

Zurück
Oben