Arraygrenzen gesprengt

[scaupe]

Hallo,

ich habe ein kleines Programm entwickelt und habe nun mit Expcetions zu kämpfen.
Das Thema der Fehlerbehandlung ist wichtig und habe bisher keine Hilfe gefunden, welche besonders für Anfänger gut geeignet ist.

1. Ich bin Anfänger und suche gute, interaktive Tutorials zur Behandlung von Fehlern. Wer kann was empfehlen? :rtfm:

2. Die Fehlermeldung beim dem folgenden Programm weist auf eine Grenzüberschreitung im Array hin. Der Hinweis lässt vermuten das der Array-Index überläuft?! Im Textdokument "zeitreihe" stehen 30 Zahlen.
Sieht hier der geübte Programmierer den Fehler?


Folgende Fehlermeldung erhalte ich:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 11
at Bruchpunktanalyse.main(Bruchpunktanalyse.java:39)

Der Code sieht folgendermaßen aus:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
 
 
public class Bruchpunktanalyse
{
 
  public static void main(String[] args) throws IOException 
  {
    int elmnt = 0;
    String rd;
    float zahl = 0;
 
    BufferedReader inData = new BufferedReader(new FileReader("zeitreihe.txt"));
 
    while ((rd = inData.readLine()) != null)  //In den Textdokument stehen x-Zahlen untereinander
    {                                                   //Diese Anzahl muss ich für weitere Berechnungen ermitteln
      elmnt++;                                      //unter der Variablenreferenz elmnt wird die Elementenzahl 
    }                                                  //gespeichert
    

    float[] zeitreihe = new float[elmnt];    //Ein Array mit x-Speicherplätzen wird erzeugt
    BufferedReader inData2 = new BufferedReader( new FileReader("zeitreihe.txt"));
    

    for (int i = 0; i < elmnt ; i++)
    {
    zeitreihe [i] = Float.parseFloat(inData2.readLine()); //Das Array wird mit den Elementen der
    }                                                                    //Zeitreihe gefüllt



//Die folgende for-Schleifenverschachtelung ist die eigentliche Analyse
//(Diese Rechenvorschrift soll ermitteln wo der wahrscheinlichste Bruchpunkt liegt...)
    for (int k = 1; k <= elmnt - 1; k++)
    {
       for (int p = 1; p <= k; p++)
       {
           for (int j = k + 1; j <= elmnt; j++)
           {
           zahl = Math.signum( zeitreihe [p] - zeitreihe[j])+ zahl;
           }
       }
    System.out.println( zahl );
    zahl = 0; 
    }
  }
}

 

[JCODA]

Huhu,

bei dem Array

float[] zeitreihe = new float[elmnt];

hat das letzte Element den Index elmnt-1.

beim letzen Schleifendurchlauf hier:

for (int j = k + 1; j <= elmnt; j++){
        zahl = Math.signum( zeitreihe [p] - zeitreihe[j])+ zahl;
 }

wird jedoch zeitreihe[elmnt] abgefragt

Für Übungszwecken mag das mit den Arrays ganz okay sein, ich würde es aber mit einer Liste lösen.

 

[Fu3L]

for (int j = k + 1; j <= elmnt; j++)

Wenn du ein Array hast, das x lang ist, dann schreibt man als Bedingung für den Index normalerweise:

for(int i = 0; i < x; x++)

Also bis der Index nicht mehr kleiner als die Array Länge ist und man startet bei 0, da Arrays von 0 bis x-1 indiziert werden.

 

[Andi_CH]

		int[] iArr = new int[42];
		for(int i=0; i<42; i++) {
			iArr[i] = i;
		}

Finde ich nicht optimal, weil sicher der Wert in der for-Schliefe vergessen geht, wenn die Arraylänge mal verändert wird. Die beiden folgenden sind besser.

Allerdings gibt es, wie schon erwähnt, Datenstrukturen, die ihre Länge automatisch den Bedürftnissen anpassen, was aber sicher einen gewissen Overhead mit sich bringt. Für mich sind Arrays noch längst nicht tot

		final int arrLength = 42;
		int[] iArr = new int[arrLength];
		for(int i=0; i<arrLength ; i++) {
			iArr[i] = i;
		}

		int[] iArr = new int[42];
		for(int i=0; i<iArr.length ; i++) {
			iArr[i] = i;
		}

 

[scaupe]

Ahhhhh, man man man

Ja, ihr habt exakt auf den Fehler gezeigt den ich noch ausbessern musste.
Die Problematik mit der Array-Indizierung war das Problem.
Die Berechnungsergebnisse sind erstmal exakt, nun folgt noch eine benutzerfreundlichere Gestaltung...

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
 
 
public class Bruchpunktanalyse
{
 
  public static void main(String[] args) throws IOException 
  {
    int elmnt = 0;
    String rd;
    float zahl = 0;
 
    BufferedReader inData = new BufferedReader(new FileReader("zeitreihe.txt"));
 
    while ((rd = inData.readLine()) != null) 
    {
      elmnt++;
    }
                                          //System.out.println( elmnt);

    float[] zeitreihe = new float[elmnt];
    BufferedReader inData2 = new BufferedReader( new FileReader("zeitreihe.txt"));
    

    for (int i = 0; i < elmnt ; i++)
    {
    zeitreihe [i] = Float.parseFloat(inData2.readLine());
    }


    for (int k = 1; k < elmnt; k++) //U(k,n) werden berechnet bis k = elmnt - 1
    {
       for (int p = 0; p < k; p++)
       {
           for (int j = k; j < elmnt; ++)
           {
           zahl = Math.signum( zeitreihe [p] - zeitreihe[j])+ zahl;
           }
       }
     
    System.out.println( zahl );
    zahl = 0; 
    }
  }
}

Dankeschön. Auch für den Hinweis das es "schönere" Datentypen gibt.

Aber vieleicht kennt jemand noch tolle, interaktive Turtorials für die allgemeine Fehlerbehandlung? Es soll für Anfänger wie mich geeignet sein.

 

[Empire Phoenix]

Tutorial / Java Grundlagen / Exceptions