IndexOutOfBoundsException

Diese Exception wird immer verwendet, wenn man mit Listen oder Arrays umgeht. Bei Listen wie ArrayList wird die IndexOutOfBoundsException eingesetzt, bei richtigen Arrays wird die ArrayIndexOutOfBoundsException verwendet - eine Unterklasse der IndexOutOfBoundsException.

Codebeispiel 1

    private void checkElementIndex(int index)
    {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException
            ("index ausserhalb: " + index);
    }

Dies ist eine private Hilfsmethode aus der Klasse MyArrayList. Der Parameter index darf einerseits nicht negativ sein, denn Arrayelemente mit negativen Indizes gibt es nicht. Andererseits darf der Parameter auch keinen größeren Wert haben als die Größe der ArrayList (size). Beide Vorgaben werden in der if-Bedingung geprüft, und wenn eine der beiden Ausschluss-Bedingungen erfüllt ist, wird eine IndexOutOfBoundsException geworfen.

Überlegung

Man könnte nun auf den Gedanken kommen, die Fehlerbehandlung mit try-catch gleich in der Methode selbst vorzunehmen:

private void checkElementIndex(int index)
{
    try
    {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException
            ("index ausserhalb: " + index);
    }
    catch (IndexOutOfBoundsException e)
    {
        System.out.println("Fehler: " + e.getMessage());
    }
}

Diese Idee wäre aber nicht so gut. Die Methode würde nach dem Auffangen der Exception (catch) einfach eine Fehlermeldung in die Konsole schreiben, was vielleicht vom Benutzer der Methode gar nicht eingeplant war. Und die aufrufende Methode würde überhaupt nicht erfahren, dass ein ungültiger Index vorliegt. Prüfmethoden wie checkElementIndex() sollten also auf jeden Fall die Exception nicht sofort abfangen und selbst behandeln, sondern mit throw an die aufrufende Methode weitergeben.

Codebeispiel 2

public class DemoArray
{
    public static void main(String[] args)
    {
        int[] zahlen = new int[3];

        zahlen[0] = 10;
        zahlen[1] = 20;
        zahlen[2] = 30;

        System.out.println(zahlen[3]);
    }
}

Ein Array-Element mit dem Index 3 existiert nicht; dieser Index liegt außerhalb des gültigen Bereichs 0 bis 2. Hier findet kein Exception-Handling statt, daher wird beim Programmstart eine ArrayIndexOutOfBoundsException ausgelöst.

Codebeispiel 3

public class TextDemo
{
    public char zeichenAnPosition(String text, int index)
    {
        if (index < 0 || index >= text.length())
            throw new IndexOutOfBoundsException
            ("ungueltiger Index: " + index);

        return text.charAt(index);
    }
}

Dieses Beispiel ist sinnvoller als das aus der Zwischendurch-Aufgabe. Der Parameter index gibt eine Position innerhalb eines Strings an. Ist der Index negativ oder größer bzw. gleich der String-Länge, dann liegt er außerhalb des gültigen Bereichs. In diesem Fall wird deshalb eine IndexOutOfBoundsException geworfen.

Codebeispiel 4

public class MatrixDemo
{
    private int[][] matrix;

    public MatrixDemo()
    {
        matrix = new int[3][4];
    }

    public int getWert(int zeile, int spalte)
    {
        if (zeile < 0 || zeile >= matrix.length)
            throw new IndexOutOfBoundsException
            ("ungueltige Zeile: " + zeile);

        if (spalte < 0 || spalte >= matrix[0].length)
            throw new IndexOutOfBoundsException
            ("ungueltige Spalte: " + spalte);

        return matrix[zeile][spalte];
    }
}

Hier sehen wir die Anwendung der IndexOutOfBoundsException auf ein zweidimensionales Array, bei dem zwei Indizes geprüft werden müssen. Daher kann die IndexOutOfBoundsException auch zweimal geworfen werden, jeweils mit einer sinnvollen Fehlermeldung.

Warum wird bei diesem Beispiel keine ArrayIndexOutOfBoundsException verwendet?

In diesem Beispiel wird die Exception bereits geworfen, bevor überhaupt auf ein Array-Element zugegriffen wird. Eine ArrayIndexOutOfBoundsException tritt typischerweise dann auf, wenn bei einem tatsächlichen Array-Zugriff ein ungültiger Index verwendet wird, also etwa bei zahlen[5] in einem zu kleinen Array. Sie wird dann automatisch von der JVM ausgelöst.

Wenn man einen Index jedoch vorher selbst prüft und bei einem unzulässigen Wert die Exception mit throw auslöst, verwendet man meist allgemeiner eine IndexOutOfBoundsException. Das gilt auch dann, wenn sich die Prüfung auf ein Array bezieht. Die IndexOutOfBoundsException ist in solchen Fällen die bessere Wahl.