Java ArrayIndexOutOfBoundsException – Java ArrayIndexOutOfBoundsException

最后修改: 2022年 2月 8日

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).

简而言之,经验法则是0 <= index <(数组的大小)。

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(
    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 is being compared as less than or equal to the length of our existing array numbers. So, in the last iteration, the value of will become 5.

在上述终止表达式中,循环变量i被比较为小于或等于我们现有数组numbers的长度。i 的值将变成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(

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.

如果我们的应用程序运行在Java 1.5或更高的版本上,我们应该使用增强的for loop语句,它是专门为迭代集合和数组而开发的。而且,它使我们的循环更加简洁,易于阅读。

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.


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.


As always, the source code for all of these examples is available over on GitHub.