Java java.lang.ArrayIndexOutOfBoundsException

[arkaduus]

[ERLEDIGT!]java.lang.ArrayIndexOutOfBoundsException

Ich habe den Fehler beheben können. Vielen Dank an dieser Stelle für die schnelle Hilfe.

Hi,
irgendwie funktioniert mein Code nicht richtig - ich könnte also ein wenig Hilfe gebrauchen
Geplant ist, dass eine Breite eingelesen wird (main), und alle möglichen Berge (2d also strich hoch,strich runter, strich grade) mit dieser Breite rekursiv berechnet werden (bergerweitern) und anschließend ausgegeben.
die Fehlermeldung lautet:
Exception in Thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
at berge.BergErhoehen(berge.java:35)
at berge.Bergerweitern(berge.java:16)
at berge.Bergerweitern(berge.java:26)
at berge.main(berge.java:55)

at berge.Bergerweitern(berge.java:26)
erscheint wenn Breite größer als 1 gewählt wird (bei "2" 1 mal, bei "3" 2 mal...)

Es liegt nicht an der for schleife (oder nicht nur ...)!

import AlgoTools.IO;
public class berge{
public static void Bergerweitern(int n, int Breite,
                                         int[] Berghoehe)  {
       if (n < Breite) {
            if (Berghoehe[n] > 0) {
                 int[] Berghoehe2 = new int[Breite];
                 for (int i=0; i<n; i++) {
                   Berghoehe2[i] = Berghoehe[i];
                 }
                 int[] Berghoehe3 = new int[Breite];
                 for (int i=0; i<n; i++) {
                   Berghoehe3[i] = Berghoehe[i];
                 }
                 n=n+1;
                 Bergerweitern(n,Breite,BergErhoehen (n,Breite, Berghoehe));
                 Bergerweitern(n,Breite,BergGleich (n,Breite, Berghoehe2));
                 Bergerweitern(n,Breite,BergVerkleinern (n,Breite, Berghoehe3));
                }
            else {
                 int[] Berghoehe2 = new int[Breite];
                 for (int i=0; i<n; i++) {
                   Berghoehe2[i] = Berghoehe[i];
                 }
                 n=n+1;
                 Bergerweitern(n,Breite,BergErhoehen (n,Breite, Berghoehe));
                 Bergerweitern(n,Breite,BergGleich (n,Breite, Berghoehe2));
                }
       }
       else {
          IO.println(Berghoehe);
       }
}
       public static int[] BergErhoehen (int n, int Breite, int[] Berghoehe) {
         Berghoehe[n] = Berghoehe[n-1]+ 1 ;
         return Berghoehe;
       }
       public static int[] BergGleich (int n,int Breite,int[] Berghoehe2) {
          Berghoehe2[n] = Berghoehe2[n-1] ;
          return Berghoehe2;
       }
       public static int[] BergVerkleinern (int n, int Breite,int[] Berghoehe3) {
          Berghoehe3[n] = Berghoehe3[n-1]- 1 ;
          return Berghoehe3;
       }
       public static void main (String[] argv) {
           int Breite;
           int n;
           int[] Berghoehe;
           Breite = IO.readInt();
           Breite = Breite+1;
           Berghoehe = new int[Breite];
           n = 1;
           Berghoehe[0] = 0;
           Bergerweitern (n, Breite, Berghoehe);
           }
       }

Ich würde mich sehr über eure Hilfe freuen

 

[CoolHandLuke]

mach mal in die Methode "Bergerhoehen" einen System.out.println(n) rein - direkt vor der Berghoehe[n]= ...

 

[Shio]

das einzige was mir einfällt ist, dass n in der for-schleife über die array-größe hinausgeht.
versuch mal als bedinung: i < (n-1)

 

[Ernie123]

Müsste die for-Schleife nicht nur bis n -1 laufen? Da das Array ja bei 0 beginnt.

 

[arkaduus]

@CoolHandLuke
dann gibt er die Werte
2 und 3 aus (bei einer Eingabe von 2)
Wenn ich 10 Eingebe läuft es bis 11 etc.

@Shio
das ändert garnichts

Ps: abgesehen davon das es nicht funktioniert scheint er nur die erhoehe schleife zu durchlaufen ? Bzw die, die an erster stelle steht

 

[Shio]

versuch es mal mit ner try & catch anweisung, damit du den ort eingrenzen kannst.

 

[DragonIce]

@ arkaduus: Deine Methode BergErhoehen (int n, int Breite, int[] Berghoehe) ist der knackende Punkt.
Dort wird irgendwas mit deinem n nicht stimmen.
Da ich die Library nicht habe, kann ich es mir leider nicht genauer angucken

 

[arkaduus]

habs rausbekommen:

public static int[] BergErhoehen (int n, int Breite, int[] Berghoehe) {
Berghoehe[n-1] = Berghoehe[n-2]+ 1 ;
return Berghoehe;

Es musste jeweils das n um einen erniedrigt werden, da ich ja mit n=1 gestartet bin (rechts von -1 auf -2 links von -0 auf -1)
das gleiche natürlich bei den andern beiden methoden zum verlängern des Arrays
Ferner musste ich auch oben bei der Abfrage der aktuellen Höhe n verringern

if (Berghoehe[n-1] > 0) {

außerdem musste ich die Ausgabe verändern
for (int i=0; i < Berghoehe.length; i++){
IO.print(Berghoehe);
}
IO.println();

Vielen Dank für eure Hilfe :]

 

[WoD]

Hallo,

ich kämpfe gerade mit einem ähnlichen Problem. Es geht darum zwei Arrays auf ihre Werte zu überprüfen:

public class vergleicheArrays {

	public static void main(String[] args) {
		int[] arrayA = {1,4,3};
		int[] arrayB = {1,4,3};
		System.out.println(vergleiche(arrayA, arrayB));
	}
	
	public static int vergleiche(int[] arrayA, int[] arrayB) {
		if (arrayA.length == arrayB.length) {
			System.out.println("Arrays gleich lang");
		}
		else {
			System.out.println("Arrays ungleich lang");
		}
		int i = 0;
		int h = 0;
		while (arrayA[i] == arrayB[h]) {
	[COLOR="Lime"]		if (i < arrayA.length) {
			i++;
			}
			if (h < arrayB.length) {
			h++;
			}[/COLOR]
		}
		if (arrayA[i] != arrayB[h]) {
			System.out.print("Array-Werte verschieden, erster Unterschied an Stelle: ");
		}
		else {
			System.out.print("Array-Werte identisch, Gesamtlänge des Arrays: ");
		}
		return i;
	}
}

Arrays gleich lang
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
at vergleicheArrays.vergleiche(vergleicheArrays.java:19)
at vergleicheArrays.main(vergleicheArrays.java:7)

Das Problem muss mit den grün hervorgehobenen if-Anweisungen zu tun haben. Nur verstehe ich nicht, warum die Anweisung falsch sein soll und zu einer "OutOfBoundException" führt.
Gebe ich für die Arrays unterschiedliche Werte ein, funktioniert das Programm problemlos.

Wie muss ich die if-Bedienung umformulieren, damit es funktioniert?

 

[Relict]

Ich vermute bei identischen Werten in beiden arrays läuft sich die Schleife tot.
while (arrayA == arrayB[h]) {

Hier fehlt es an einer zuverlässigen Ausstiegsbedingung.
Ich würde den Vergleich innerhalb der schleife machen und solange bis der max-idx eines arrays erreicht ist und am besten noch dazu gleich beim 1. unterschied aus der schleife aussteigen. Mehr willst du doch vermutlich sowieso nicht abfragen, oder?

zb.

       int i = 0;
       int ungleich = 0;
	while (i < arrayA.length && i < arrayB.length) {
			if (arrayA[i] != arrayB[i]) {
				ungleich = 1;
				break;
			}
			i++;
	}
	if(ungleich == 1){
	// i = position 1. unterschied 
	}
	else{
	// identisch
	}

 

[WoD]

Ja genau, die genaue Stelle an der unterschiedliche Werte auftreten müsste ich nicht einmal nennen. Jedoch weiß ich nicht, wie ich die return-Anweisung geschickter formulieren könnte.

Beim Versuch deinen Code zu implementieren, bekomme ich aber leider wieder den selben Fehler:

public class B5A1a {

	public static void main(String[] args) {
		int[] arrayA = { 1, 4, 3 };
		int[] arrayB = { 1, 4, 3 };
		System.out.println(vergleiche(arrayA, arrayB));
	}

	public static int vergleiche(int[] arrayA, int[] arrayB) {
		if (arrayA.length == arrayB.length) {
			System.out.println("Arrays gleich lang");
		} else {
			System.out.println("Arrays ungleich lang");
		}

		int i = 0;
        int ungleich = 0;
		while (i < arrayA.length && i < arrayB.length) {
			if (arrayA[i] != arrayB[i]) {
                ungleich = 1;
				System.out.println((ungleich)+ " Werte unterschiedlich");
				break;
			}
			i++;
		}
		if (arrayA[i] == arrayB[i]) {
			System.out.println("Werte identisch");
		}
		return 0;
	}
}

 

[Relict]

ja klar weil Du mein anschliessendes if durch Dein
if (arrayA == arrayB) {
System.out.println("Werte identisch");
}

ersetzt hast. Das i ist aber - falls kein vorzeitiger Schleifenausstieg - bereits >= arrayX.length und somit längst out of bound.

probier mal sowas in der Art:

if(ungleich == 1){
	// inhalte unterschiedlich
	// i = position 1. unterschied 
	System.out.println("Array-Werte verschieden, erster Unterschied an Stelle: ");
}
else if(arrayA.length != arrayB.length){
	//falls array inhalte zwar soweit gleich, aber arrays  unterschiedlich lang
  // i = position 1. unterschied 
	System.out.println("Array-Länge verschieden, erster Unterschied an Stelle: ");
}
else{
	// Länge und Inhalt identisch, Länge = arrayA.length
	System.out.println("Array-Werte identisch, Gesamtlänge des Arrays: ");
}

für die return Anweisung kannste dir einen Wert bzw. Status/Flag für jede Möglichkeit setzen (jeweils innerhalb der Abfragen) und den
zurück geben.