Java ArrayIndexOutOfBoundsException

1. Overview

In this tutorial, we’ll discuss ArrayIndexOutOfBoundsException in Java. We’ll understand why it occurs and how to avoid it.

2. When Does ArrayIndexOutOfBoundsException Occur?

As we know, in Java, an array is a static data structure, and we define its size at the time of creation.

We access the elements of an array using indices. Indexing in an array starts from zero and must never be greater than or equal to the size of the array.

In short, the rule of thumb is 0 <= index < (size of array).

ArrayIndexOutOfBoundsException occurs when we access an array, or a Collection, that is backed by an array with an invalid index. This means that the index is either less than zero or greater than or equal to the size of the array.

Additionally, bound checking happens at runtime. So, ArrayIndexOutOfBoundsException is a runtime exception. Therefore, we need to be extra careful when accessing the boundary elements of an array.

Let’s understand some of the common operations that lead to ArrayIndexOutOfBoundsException.

2.1. Accessing an Array

The most common mistake that may happen while accessing an array is forgetting about the upper and lower bounds.

The lower bound of an array is always 0, while the upper bound is one less than its length.

Accessing the array elements out of these bounds would throw an ArrayIndexOutOfBoundsException:

int[] numbers = new int[] {1, 2, 3, 4, 5};
int lastNumber = numbers[5];

Here, the size of the array is 5, which means the index will range from 0 to 4.

In this case, accessing the 5th index results in an ArrayIndexOutOfBoundsException:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
    at ...

Similarly, we get ArrayIndexOutOfBoundsException if we pass a value less than zero as an index to numbers.

2.2. Accessing a List Returned by Arrays.asList()

The static method Arrays.asList() returns a fixed-sized list that is backed by the specified array. Moreover, it acts as a bridge between array-based and collection-based APIs.

This returned List has methods to access its elements based on indices. Also, similar to an array, the indexing starts from zero and ranges to one less than its size.

If we try to access the elements of the List returned by Arrays.asList() beyond this range, we would get an ArrayIndexOutOfBoundsException:

List<Integer> numbersList = Arrays.asList(1, 2, 3, 4, 5);
int lastNumber = numbersList.get(5);

Here again, we are trying to get the last element of the List. The position of the last element is 5, but its index is 4 (size – 1). Hence, we get ArrayIndexOutOfBoundsException as below:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
    at java.base/java.util.Arrays$ArrayList.get(Arrays.java:4351)
    at  ...

Similarly, if we pass a negative index, say -1, we will get a similar result.

2.3. Iterating in Loops

Sometimes, while iterating over an array in a for loop, we might put a wrong termination expression.

Instead of terminating the index at one less than the length of the array, we might end up iterating until its length:

int sum = 0;
for (int i = 0; i <= numbers.length; i++) {
    sum += numbers[i];
}

In the above termination expression, the loop variable i is being compared as less than or equal to the length of our existing array numbers. So, in the last iteration, the value of i will become 5.

Since index 5 is beyond the range of numbers, it will again lead to ArrayIndexOutOfBoundsException:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
    at com.baeldung.concatenate.IndexOutOfBoundExceptionExamples.main(IndexOutOfBoundExceptionExamples.java:22)

3. How to Avoid ArrayIndexOutOfBoundsException?

Let’s now understand some ways to avoid ArrayIndexOutOfBoundsException.

3.1. Remembering the Start Index

We must always remember that the array index starts at 0 in Java. So, the first element is always at index 0, while the last element is at index one less than the length of the array.

Remembering this rule will help us avoid ArrayIndexOutOfBoundsException most of the time.

3.2. Correctly Using the Operators in Loops

Incorrectly initializing the loop variable to index 1 may result in ArrayIndexOutOfBoundsException.

Similarly, the incorrect use of operators <, <=, > or >= in termination expressions of loops is a common reason for the occurrence of this exception.

We should correctly determine the use of these operators in loops.

3.3. Using Enhanced for Loop

If our application is running on Java 1.5 or a higher version, we should use an enhanced for loop statement that has been specifically developed to iterate over collections and arrays. Also, it makes our loops more succinct and easy to read.

Additionally, using the enhanced for loop helps us completely avoid the ArrayIndexOutOfBoundsException as it does not involve an index variable:

for (int number : numbers) {
    sum += number;
}

Here, we do not have to worry about indexing. The enhanced for loop picks up an element and assigns it to a loop variable, number, with each iteration. Thus, it completely avoids ArrayIndexOutOfBoundsException.

3.4. Using the try-catch Block

Another way to handle this error is to use a try-catch block. A try-catch construct allows us to intercept and handle exceptions that may occur at runtime:

try {
    for (int i = 0; i <= numbers.length; i++) {
        sum += numbers[i];
    }
} catch (ArrayIndexOutOfBoundsException e) {
    LOG.info("Attempted to access an index outside array bounds: {}", e.getMessage());    
    return -1;
}

In the code above, we intentionally trigger an ArrayIndexOutOfBoundsException by looping one step beyond the valid index range. Then, when the exception occurs, we log a clear message and return -1 to indicate the calculation cannot be completed. When we do use exception handling, we should provide clear and descriptive messages to make debugging easier.

4. IndexOutOfBoundsException vs. ArrayIndexOutOfBoundsException

IndexOutOfBoundsException occurs when we try to access an index of some type (String, array, List, etc.) beyond its range. It’s a superclass of ArrayIndexOutOfBoundsException and StringIndexOutOfBoundsException.

Similar to ArrayIndexOutOfBoundsException, StringIndexOutOfBoundsException is thrown when we try to access a character of a String with an index beyond its length.

5. Conclusion

In this article, we explored ArrayIndexOutOfBoundsException, some examples for how it occurs, and some common techniques to avoid it.