What causes a java.lang.ArrayIndexOutOfBoundsException and how do I prevent it? [Answered]

In this post, I’ll share the top best answers for the above-mentioned problem.

Problem: What does ArrayIndexOutOfBoundsException mean and how do I get rid of it?


Your first port of call should be the documentation that explains it reasonably clearly:

Thrown to indicate that an array has been accessed with an illegal index. The index is either negative or greater than or equal to the size of the array.

So for example:

int[] array = new int[5];
int boom = array[10]; // Throws the exception

As for how to avoid it… um, don’t do that. Be careful with your array indexes.

One problem people sometimes run into is thinking that arrays are 1-indexed, e.g.

int[] array = new int[5];
// ... populate the array here ...
for (int index = 1; index <= array.length; index++)

That will miss out the first element (index 0) and throw an exception when index is 5. The valid indexes here are 0-4 inclusive. The correct, idiomatic for statement here would be:

for (int index = 0; index < array.length; index++)

(That’s assuming you need the index, of course. If you can use the enhanced for loop instead, do so.)

What does ArrayIndexOutOfBoundsException mean and how do I get rid of it? Answer#2:

if (index < 0 || index >= array.length) {
    // Don't use this index. This is out of bounds (borders, limits, whatever).
} else {
    // Yes, you can safely use this index. The index is present in the array.
    Object element = array[index];

Update: as per your code snippet,

for (int i = 0; i<=name.length; i++) {

The index is inclusive the array’s length. This is out of bounds. You need to replace <= by <.

for (int i = 0; i < name.length; i++) {

What does ArrayIndexOutOfBoundsException mean and how do I get rid of it? Answer #3:

To put it briefly:

In the last iteration of

for (int i = 0; i <= name.length; i++) {

i will equal name.length which is an illegal index, since array indices are zero-based.

Your code should read

for (int i = 0; i < name.length; i++) 

What does ArrayIndexOutOfBoundsException mean and how do I get rid of it? Answer#4:

What causes ArrayIndexOutOfBoundsException?

If you think of a variable as a “box” where you can place a value, then an array is a series of boxes placed next to each other, where the number of boxes is a finite and explicit integer.

Creating an array like this:

final int[] myArray = new int[5]

creates a row of 5 boxes, each holding an int. Each of the boxes has an index, a position in the series of boxes. This index starts at 0, and ends at N-1, where N is the size of the array (the number of boxes).

To retrieve one of the values from this series of boxes, you can refer to it through its index, like this:


Which will give you the value of the 4th box in the series (since the first box has index 0).

An ArrayIndexOutOfBoundsException is caused by trying to retrieve a “box” that does not exist, by passing an index that is higher than the index of the last “box”, or negative.

With my running example, these code snippets would produce such an exception:

myArray[5] //tries to retrieve the 6th "box" when there is only 5
myArray[-1] //just makes no sense
myArray[1337] //waay to high

How to avoid ArrayIndexOutOfBoundsException

In order to prevent ArrayIndexOutOfBoundsException, there are some key points to consider:


When looping through an array, always make sure that the index you are retrieving is strictly smaller than the length of the array (the number of boxes). For instance:

for (int i = 0; i < myArray.length; i++) {

Notice the <, never mix a = in there..

You might want to be tempted to do something like this:

for (int i = 1; i <= myArray.length; i++) {
    final int someint = myArray[i - 1]

Just don’t. Stick to the one above (if you need to use the index) and it will save you a lot of pain.

Where possible, use foreach:

for (int value : myArray) {

This way you won’t have to think about indexes at all.

When looping, whatever you do, NEVER change the value of the loop iterator (here: i). The only place this should change value is to keep the loop going. Changing it otherwise is just risking an exception, and is in most cases not necessary.


When retrieving an arbitrary element of the array, always check that it is a valid index against the length of the array:

public Integer getArrayElement(final int index) {
    if (index < 0 || index >= myArray.length) {
        return null; //although I would much prefer an actual exception being thrown when this happens.
    return myArray[index];

Follow Programming Articles for more!

About ᴾᴿᴼᵍʳᵃᵐᵐᵉʳ

Linux and Python enthusiast, in love with open source since 2014, Writer at programming-articles.com, India.

View all posts by ᴾᴿᴼᵍʳᵃᵐᵐᵉʳ →