Array Index Out Of Bounds Exception in Java

ArrayIndexOutOfBoundsException in Java is a runtime exception that occurs when an attempt is made to access an array element using an invalid index. The valid index range for array indexing in Java is [0, n-1], where n represents the size of the array. If an index is negative or equal to or greater than n, Java throws an ArrayIndexOutOfBoundsException. This exception is exclusively generated at runtime and helps prevent unintended memory access beyond the defined array boundaries. In this blog, you are going to learn about Java’s ArrayIndexOutOfBoundsException in detail, along with its causes, prevention, and best practices

Table of Contents:

• What is ArrayIndexOutOfBoundsException in Java
• Common Causes of ArrayIndexOutOfBoundsException in Java
• How to Prevent ArrayIndexOutOfBoundsException in Java
• Best Practices to Avoid ArrayIndexOutOfBoundsException in Java
• How to Fix an ArrayIndexOutOfBoundsException in Java
• Difference Between ArrayIndexOutOfBoundsException and IndexOutOfBoundsException
• Real-World Example of ArrayIndexOutOfBoundsException in Java
• ArrayIndexOutOfBoundsException in 2D and Multi-Dimensional Arrays
• Conclusion

What is ArrayIndexOutOfBoundsException in Java

An array is a collection of similar types of data. It is the base for many advanced data structures, e.g., a list or a binary tree. It  stores the elements in a contiguous memory location, and it can also have multiple dimensions  

The java.lang.ArrayIndexOutOfBoundsException is a Java runtime exception and is thrown when the program is being executed. The Java compiler never checks for this error during the compilation process. 

The java.lang.ArrayIndexOutOfBoundsException is among the most frequently occurring exceptions in Java. This Java array exception is caused when the developer attempts to retrieve the value of an element from an array beyond an invalid index, which means due to invalid array indexing in Java. This Java Exception was introduced in Java from JDK Version 1.0 onwards. It can occur due to many reasons, like when we try to access the value of an element in the array at a negative index or an index greater than the size of the array.

Common Causes of ArrayIndexOutOfBoundsException in Java

The ArrayIndexOutOfBoundsException in Java occurs when an invalid index is used to access an element in an array. Below are some common causes of it:

1. Accessing a Negative Index

In Java, array indices must always be positive. If an attempt is made to access an element having a negative index, an ArrayIndexOutOfBoundsException will occur.  

For example:

Output:  

2. Accessing Index Greater Than or Equal to the Array’s Length

The correct indexes for an array are between 0 to the array.length – 1. If an index is greater than or equal to the array’s size, then an ArrayIndexOutOfBoundsException will occur, due to the invalid array indexing in Java. 

For example:

Output:  

3. Accessing an Element Beyond the End of a Multi-Dimensional Array

Similar to one-dimensional arrays, multi-dimensional arrays also have limits. If an index exceeds the dimensions of any of the arrays, an exception will be thrown.

For example:

Output:  

Master Java Today - Accelerate Your Future

Enroll Now and Transform Your Future

Explore Program

4. Accessing Off-by-One Errors

One of the most common errors is the “off-by-one” error, where a loop runs too many times or too few times when an invalid index n is accessed. For example, if you loop from 0 to arr.length rather than 0 to arr.length – 1, it will try to access an out-of-bounds index. It is also known as Java index error.

For example:

Output:  

5. Improper Array Copy or Manipulation

When data is copied from one array to another, if the destination array is not large enough to hold the data being copied from the source array, an ArrayIndexOutOfBoundsException can occur. This occurs when copying the elements from an array without checking the destination array’s size.

For example:

Output:  

6. Using Variables without Validation

When the index for accessing an array is calculated, and obtained from the user input, or derived from an external source, there’s a risk of using an invalid index if the value is not properly checked. If the index is negative or greater than or equal to the array’s length, it will result in an ArrayIndexOutOfBoundsException.

For example:

Output: 

How to Prevent ArrayIndexOutOfBoundsException in Java

To prevent the Java array exception, ArrayIndexOutOfBoundsException, the following points should be kept in mind:

• One must check the limit of an array prior to accessing its elements.
• An array in Java begins with index 0 and ends with index length – 1, so accessing outside this range of elements will result in an ArrayIndexOutOfBoundsException.
• An empty array does not contain any elements, so attempting to access an element from such an array would raise an exception.
• When iterating over the elements of an array with loops, take care of the starting and ending conditions of the loop, so that they are always within the range of the array.
• Write test cases for the conditions, such as accessing the first or last element of an array, or working with empty arrays. This can help identify the out-of-bounds errors

Best Practices to Avoid ArrayIndexOutOfBoundsException in Java

To find the Array Index Out Of Bounds Exception in a Java application, you can use a combination of the following methods:

• Adding the try-catch blocks around the code can cause an exception. The catch block will contain a print statement to print the exception message and the stack trace.
• Use a debugger in the code to check the values of variables at each step. This can help you to find the specific line of code that is causing the exception and the values of the variables involved.
• Turn on logging in your application and check for the log files for any error messages or stack traces that are related to the ArrayIndexOutOfBoundsException.
• Use an Application Performance Management (APM) Tool like FusionReactor, which will check your application for errors. This can provide information about the error, like the line number and method name.

Unlock Your Future in Java

Start Your Java Journey for Free Today

Explore Program

How to Fix an ArrayIndexOutOfBoundsException in Java?

To fix an ArrayIndexOutOfBoundsException in Java, you need to ensure that you are always accessing array elements with having valid index. The index of an array should be between 0 and array.length – 1, where array.length is the number of elements in the array. Here are some steps you can use to fix it:

1. Check the Index Before Accessing the Array

Always check that the index you’re using is within the range of the array. This ensures that you’re not trying to access an element that doesn’t exist.

2. Use Loops Carefully

When iterating through an array using a loop, ensure the loop runs within the valid range of indices. For example, a common mistake is using i <= arr.length in the loop condition, which causes the loop to go one iteration too many.

Incorrect Loop 

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

    System.out.println(arr[i]);

}

Fixed Loop

for (int i = 0; i < arr.length; i++) {  // it should be i < arr.length

    System.out.println(arr[i]);

} 

3. Handle Empty Arrays

An empty array has no elements, so any attempt to access an element will result in an ArrayIndexOutOfBoundsException. So, always check if the array is empty before accessing elements.

4. Check Multi-Dimensional Array Indices

When working with multi-dimensional arrays (e.g., 2D arrays), ensure that both row and column indices are within bounds. Each dimension in a multi-dimensional array has its own length.

5. Use Try-Catch Blocks for Exception Handling in Java

Although preventing ArrayIndexOutOfBoundsException is ideal, you can also fix it using a try-catch block, which helps in exception handling in Java. The try-catch block catches the ArrayIndexOutOfBoundsException and prevents the program from crashing.  

Output:

By following the above steps, you can fix an ArrayIndexOutOfBoundsException in Java applications.

Difference Between ArrayIndexOutOfBoundsException and IndexOutOfBoundsException

Here’s a comparison table showing the difference between ArrayIndexOutOfBoundsException and IndexOutOfBoundsException in Java on the basis of different aspects:

Real-World Example of ArrayIndexOutOfBoundsException in Java

Here’s a real-world example of ArrayIndexOutOfBoundsException in Java.

Example: Accessing Months of the Year

Output:

Explanation: This code stores all 12 months in a string array. The user inputs 12, expecting to get “December”, but array indexing in Java starts from 0. So months[12] is invalid because the last valid index is 11. This causes an ArrayIndexOutOfBoundsException at runtime.

How to Fix It: To fix the error, subtract 1 from the user input to match Java’s 0-based indexing. So instead of months[input], use months[input – 1]. This makes months[11] return “December” correctly. Always check that the input is between 1 and 12 to avoid other errors.

ArrayIndexOutOfBoundsException in 2D and Multi-Dimensional Arrays

In Java, a 2D or multi-dimensional array is like a table made of rows and columns. A Java array exception, ArrayIndexOutOfBoundsException, happens when you try to access a row or column that doesn’t exist. For example, if a 2D array has 2 rows, trying to access row 3 (index 2) will cause this error. You can avoid it by checking the size of the array using array.length for rows and array[i].length for columns. Always start counting from 0, not 1.

Example 1: 2D Array

Output:

Explanation: This code creates a 2D array with 2 rows. It then tries to access the element at row index 2 and column index 1. Since arrays in Java start from 0, the valid row indexes are 0 and 1 only. Trying to access matrix[2][1] causes an ArrayIndexOutOfBoundsException because the third row doesn’t exist.

Example 2: Valid row, invalid column

Output:

Explanation: This code creates a 2D array with 2 rows and 3 columns. It tries to access matrix[1][3], which means the 4th element in the second row. But the second row only has elements at indices 0, 1, and 2. So, accessing index 3 causes an ArrayIndexOutOfBoundsException.

Conclusion

ArrayIndexOutOfBoundsException in Java occurs when an illegal index is used to access an element from an array. To prevent this Java array exception, you should always check that the index stays in the range, i.e., between 0 and array.length – 1. The best practices include bounds checking before accessing, loop handling with care, and the use of exception handling in Java, i.e., try-catch blocks, to avoid a crash of the application.

If you want to learn more about Java, you can refer to our Java Course.

Array Index Out Of Bounds Exception in Java – FAQs