Что вызывает исключение java.lang.ArrayIndexOutOfBoundsException и как его предотвратить?

Что означает ArrayIndexOutOfBoundsException и как от него избавиться?

Вот пример кода, который вызывает исключение:

String[] name = { "tom", "dick", "harry" };
for (int i = 0; i <= name.length; i++) {
    System.out.println(name[i]);
}

Ответы

Ответ 1

Первым портом вызова должна быть документация, которая объясняет это достаточно четко:

Подбрасывается, чтобы указать, что к массиву был обращен незаконный индекс. Индекс является либо отрицательным, либо большим или равным размеру массива.

Итак, например:

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

Как избежать этого... um, не делайте этого. Будьте осторожны с индексами массива.

Одна проблема, с которой иногда сталкиваются люди, - это то, что массивы 1-индексируются, например.

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

Это пропустит первый элемент (индекс 0) и выдаст исключение, если индекс равен 5. Действительные индексы здесь 0-4 включительно. Правильный, идиоматический оператор for здесь:

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

(Предположим, что вам нужен индекс, конечно. Если вы можете использовать расширенный цикл for, сделайте это.)

Ответ 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];
}

Смотрите также:

Учебные руководства Java - Основы языка - Массивы

Обновление: согласно вашему фрагменту кода,

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

Индекс включает длину массива. Это за пределами. Вам нужно заменить <= на <.

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

Ответ 3

Из этой превосходной статьи: ArrayIndexOutOfBoundsException в цикле for

Короче говоря:

В последней итерации

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

i будет равен name.length, что является недопустимым индексом, поскольку индексы массива начинаются с нуля.

Ваш код должен читать

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

Ответ 4

Это означает, что вы пытаетесь получить доступ к индексу массива, который недопустим, поскольку он не находится между границами.

Например, это инициализировало бы примитивный целочисленный массив с верхней границей 4.

int intArray[] = new int[5];

Программисты подсчитываются с нуля. Таким образом, это, например, выбрало бы ArrayIndexOutOfBoundsException, поскольку верхняя граница равна 4, а не 5.

intArray[5];

Ответ 5

Чтобы исключить исключение из строя индекса массива, следует использовать extended- for, где и когда они могут.

Основная мотивация (и использование) - это когда вы выполняете итерацию, и вам не требуются сложные шаги итерации. Вы не сможете использовать расширенный for для перемещения назад в массив или только для итерации по каждому другому элементу.

Гарантируется, что при выполнении этого не заканчивается выполнение элементов, и ваш [исправленный] пример легко конвертируется.

Код ниже:

String[] name = {"tom", "dick", "harry"};
for(int i = 0; i< name.length; i++) {
    System.out.print(name[i] + "\n");
}

... эквивалентно этому:

String[] name = {"tom", "dick", "harry"};
for(String firstName : name) {
    System.out.println(firstName + "\n");
}

Ответ 6

Что вызывает ArrayIndexOutOfBoundsException?

Если вы считаете, что переменная является "полем", где вы можете поместить значение, тогда массив представляет собой ряд ящиков, расположенных рядом с eachother, где число ящиков является конечным и явным целым числом.

Создание такого массива:

final int[] myArray = new int[5]

создает строку из 5 полей, каждая из которых имеет int. Каждый из ящиков имеет индекс, позицию в ряду ящиков. Этот индекс начинается с 0 и заканчивается на N-1, где N - размер массива (количество ящиков).

Чтобы получить одно из значений из этой серии ящиков, вы можете обратиться к нему через свой индекс, например:

myArray[3]

Который даст вам значение 4-го ящика в серии (поскольку первый ящик имеет индекс 0).

An ArrayIndexOutOfBoundsException вызван попыткой извлечь "ящик", который не существует, путем передачи индекса, который выше индекса последнего "поля" или отрицательного.

В моем примере выполнения эти фрагменты кода приведут к такому исключению:

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

Как избежать ArrayIndexOutOfBoundsException

Чтобы предотвратить ArrayIndexOutOfBoundsException, необходимо рассмотреть некоторые ключевые моменты:

Циклическое

При переходе по массиву всегда убедитесь, что индекс, который вы извлекаете, строго меньше длины массива (количество ящиков). Например:

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

Обратите внимание на <, никогда не смешивайте = там.

Возможно, у вас возникнет соблазн сделать что-то вроде этого:

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

Просто не надо. Придерживайтесь одного выше (если вам нужно использовать индекс), и это сэкономит вам много боли.

По возможности используйте foreach:

for (int value : myArray) {

Таким образом вам не придется вообще обдумывать индексы.

При циклизации, что бы вы ни делали, НИКОГДА не изменяйте значение итератора цикла (здесь: i). Единственное место, которое должно изменить значение, это сохранить цикл. Изменение в противном случае просто рискует исключением и в большинстве случаев не обязательно.

индексирование/обновление

При получении произвольного элемента массива всегда проверяйте, что он является допустимым индексом по отношению к длине массива:

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];
}

Ответ 7

В вашем коде вы получили доступ к элементам от индекса 0 до длины строкового массива. name.length дает количество строковых объектов в вашем массиве строковых объектов, то есть 3, но вы можете получить доступ только до индекса name[2], потому что массив может быть доступен от индекса 0 до name.length - 1 где вы получите name.length количество объектов.

Даже при использовании цикла for вы начали с индекса ноль, и вы должны заканчивать name.length - 1. В массиве a [n] вы можете получить доступ от формы [0] к [n-1].

Например:

String[] a={"str1", "str2", "str3" ..., "strn"};

for(int i=0;i<a.length()i++)
    System.out.println(a[i]);

В твоем случае:

String[] name = {"tom", "dick", "harry"};

for(int i = 0; i<=name.length; i++) {
    System.out.print(name[i] +'\n');
}

Ответ 8

Для данного массива длина массива равна 3 (т.е. Name.length = 3). Но поскольку он хранит элемент, начинающийся с индекса 0, он имеет максимальный индекс 2.

Итак, вместо "i ** <= name.length" вы должны написать "i <** name.length", чтобы избежать "ArrayIndexOutOfBoundsException".

Ответ 9

Вы получаете ArrayIndexOutOfBoundsException из-за i<=name.length. name.length возвращает длину строки name, которое 3. Следовательно, при попытке получить доступ к name[3], это незаконно и вызывает исключение.

Решенный код:

String[] name = {"tom", "dick", "harry"};
for(int i = 0; i < name.length; i++) { //use < insteadof <=
  System.out.print(name[i] +'\n');
}

Он определен в спецификации языка Java:

public final length поля, которая содержит количество компонентов массива. length может быть положительной или нулевой.

Ответ 10

То, как выглядит этот тип исключения при броске в Eclipse. Число в красном означает индекс, к которому вы пытались получить доступ. Таким образом, код будет выглядеть так:

myArray[5]

Ошибка вызывается при попытке получить доступ к индексу, который не существует в этом массиве. Если массив имеет длину 3,

int[] intArray = new int[3];

то единственными действительными индексами являются:

intArray[0]
intArray[1]
intArray[2]

Если массив имеет длину 1,

int[] intArray = new int[1];

то единственным действующим индексом является:

intArray[0]

Любое целое число, равное длине массива, или больше, чем оно: вне пределов.

Любое целое число меньше 0: вне пределов;

PS: Если вы хотите лучше понять массивы и сделать некоторые практические упражнения, здесь есть видео: учебник по массивам в Java

Ответ 11

Так много для этого простого вопроса, но я просто хотел выделить новую функцию на Java, которая позволит избежать всех путаниц в индексировании в массивах даже для новичков. Java-8 абстрагировала задачу итерации для вас.

int[] array = new int[5];

//If you need just the items
Arrays.stream(array).forEach(item -> { println(item); });

//If you need the index as well
IntStream.range(0, array.length).forEach(index -> { println(array[index]); })

Какая польза? Ну, с одной стороны, это читаемость, как английский. Во-вторых, вам не нужно беспокоиться о ArrayIndexOutOfBoundsException

Ответ 12

Для многомерных массивов может быть сложно получить доступ к свойству length правого измерения. Возьмем следующий код, например:

int [][][] a  = new int [2][3][4];

for(int i = 0; i < a.length; i++){
    for(int j = 0; j < a[i].length; j++){
        for(int k = 0; k < a[j].length; k++){
            System.out.print(a[i][j][k]);
        }
        System.out.println();
    }
    System.out.println();
}

Каждое измерение имеет разную длину, поэтому тонкая ошибка заключается в том, что средняя и внутренняя циклы используют свойство length того же размера (поскольку length a[i].length той же a[j].length).

Вместо этого для простоты внутренний цикл должен использовать a[i][j].length (или a[0][0].length).

Ответ 13

Наиболее распространенный случай, который я видел для кажущихся таинственными ArrayIndexOutOfBoundsExceptions, то есть, по-видимому, не вызванных вашим собственным кодом обработки массива, является одновременным использованием SimpleDateFormat. В частности, в сервлете или контроллере:

public class MyController {
  SimpleDateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy");

  public void handleRequest(ServletRequest req, ServletResponse res) {
    Date date = dateFormat.parse(req.getParameter("date"));
  }
}

Если два потока вступают в метод SimplateDateFormat.parse(), вы, скорее всего, увидите исключение ArrayIndexOutOfBoundsException. Обратите внимание на раздел синхронизации класса javadoc для SimpleDateFormat.

Удостоверьтесь, что в вашем коде нет места, которое будет обращаться к небезопасным классам потоков, таким как SimpleDateFormat, одновременно, как в сервлете или контроллере. Проверьте все переменные экземпляра ваших сервлетов и контроллеров для вероятных подозреваемых.

Ответ 14

ArrayIndexOutOfBoundsException, когда это исключение приходит, означает, что вы пытаетесь использовать индекс массива, который выходит за рамки или в условиях неработающего человека, которые вы запрашиваете больше, чем вы инициализировали.

Чтобы это предотвратить, всегда убедитесь, что вы не запрашиваете индекс, который отсутствует в массиве, т.е. Если длина массива равна 10, то ваш индекс должен находиться в диапазоне от 0 до 9

Ответ 15

ArrayIndexOutOfBounds означает, что вы пытаетесь проиндексировать позицию в массиве, который не выделен.

В этом случае:

String[] name = { "tom", "dick", "harry" };
for (int i = 0; i <= name.length; i++) {
    System.out.println(name[i]);
}

name.length равен 3, так как массив был определен с 3 объектами String.
При доступе к содержимому массива позиция начинается с 0. Так как есть 3 элемента, это будет означать name [0] = "tom", name [1] = "dick" и name [2] = "harry
Когда вы зацикливаетесь, так как я могу быть меньше или равен name.length, вы пытаетесь получить доступ к имени [3], которое недоступно.

Чтобы обойти это...

В вашем цикле for вы можете сделать я <name.length. Это предотвратит зацикливание на имени [3] и остановит на имени [2]

for(int я = 0; i<name.length; i++)
Используйте для каждого цикла

String[] name = { "tom", "dick", "harry" }; for(String n: name) { System.out.println(n); }
Используйте list.forEach(Consumer action) (требуется Java8)

String[] name = { "tom", "dick", "harry" }; Arrays.asList(name).forEach(System.out::println);
Конвертировать массив в поток - это хороший вариант, если вы хотите выполнить дополнительные "операции" с вашим массивом, например, фильтровать, преобразовывать текст, конвертировать в карту и т.д. (Требуется Java8)

String[] name = { "tom", "dick", "harry" }; --- Arrays.asList(name).stream().forEach(System.out::println); --- Stream.of(name).forEach(System.out::println);

Ответ 16

Для любого массива длины n элементы массива будут иметь индекс от 0 до n-1.

Если ваша программа пытается получить доступ к любому элементу (или памяти) с индексом массива, большим, чем n-1, тогда Java будет вызывать ArrayIndexOutOfBoundsException

Итак, вот два решения, которые мы можем использовать в программе

Поддержание счета:

for(int count = 0; count < array.length; count++) {
    System.out.println(array[count]);
}

Или какой-нибудь другой оператор цикла, например

int count = 0;
while(count < array.length) {
    System.out.println(array[count]);
    count++;
}

Лучший способ пойти с a для каждого цикла, в этом методе программисту не нужно беспокоиться о количестве элементов в массиве.
```
for(String str : array) {
    System.out.println(str);
}
```

Ответ 17

ArrayIndexOutOfBoundsException означает, что вы пытаетесь получить доступ к индексу массива, который не существует или не связан с границей этого массива. Индексы массивов начинаются с 0 и заканчиваются на длина - 1.

В вашем случае

for(int i = 0; i<=name.length; i++) {
    System.out.print(name[i] +'\n'); // i goes from 0 to length, Not correct
}

ArrayIndexOutOfBoundsException происходит, когда вы пытаетесь получить доступ индексированный элемент name.length, который не существует (индекс массива заканчивается на -1). просто заменяя <= с < решит эту проблему.

for(int i = 0; i < name.length; i++) {
    System.out.print(name[i] +'\n');  // i goes from 0 to length - 1, Correct
}

Ответ 18

Согласно вашему Коду:

String[] name = {"tom", "dick", "harry"};
for(int i = 0; i<=name.length; i++) {
  System.out.print(name[i] +'\n');
}

Если вы проверите System.out.print(name.length);

вы получите 3;

это означает, что длина вашего имени равна 3

ваш цикл работает от 0 до 3, который должен работать либо от "0 до 2", либо от "1 до 3",

Ответ

String[] name = {"tom", "dick", "harry"};
for(int i = 0; i<name.length; i++) {
  System.out.print(name[i] +'\n');
}

Ответ 19

Каждый элемент в массиве называется элементом, и каждый элемент получает доступ к его числовому индексу. Как показано на предыдущей иллюстрации, нумерация начинается с 0. Таким образом, к девятому элементу, например, следует обращаться по индексу 8.

IndexOutOfBoundsException выводится, чтобы указать, что индекс какого-либо типа (например, массив, строка или вектор) выходит за пределы диапазона.

К любому массиву X можно получить доступ с [0 до (X.length - 1)]

Ответ 20

Я вижу все ответы здесь, объясняющие, как работать с массивами и как избегать исключений индекса за пределами границ. Я лично избегаю массивов любой ценой. Я использую классы Collections, что исключает всю глупость необходимости полностью разбираться с индексами массивов. Циклические конструкции прекрасно работают с коллекциями, поддерживающими код, который легче писать, понимать и поддерживать.

Ответ 21

Если вы используете длину массива для управления итерацией цикла for, всегда помните, что индекс первого элемента в массиве равен 0. Таким образом, индекс последнего элемента в массиве на единицу меньше длины массива.

Ответ 22

Имя ArrayIndexOutOfBoundsException объясняет, что если вы пытаетесь получить доступ к значению в индексе, который выходит за пределы массива Array, возникает такое исключение.

В вашем случае вы можете просто удалить знак равенства из цикла for.

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

Лучшим вариантом является итерация массива:

for(String i : name )
      System.out.println(i);

Ответ 23

Эта ошибка возникает при переполнении циклов цикла. Давайте рассмотрим простой пример, например,

class demo{
  public static void main(String a[]){

    int[] numberArray={4,8,2,3,89,5};

    int i;

    for(i=0;i<numberArray.length;i++){
        System.out.print(numberArray[i+1]+"  ");
    }
}

Сначала я инициализировал массив как "numberArray". то некоторые элементы массива печатаются с использованием цикла. Когда цикл запускает время "i", напечатайте элемент (numberArray [i + 1].. (когда значение я равно 1, будет напечатан элемент numberArray [i + 1].) Предположим, что, когда я = (numberArray. length-2), последний элемент массива печатается. Когда значение "i" переходит к (numberArray.length-1), нет значения для печати. В этот момент происходит "ArrayIndexOutOfBoundsException". Я надеюсь, что вы можете получить idea.thank вас!

Ответ 24

Вы можете использовать Optional в функциональном стиле, чтобы избежать NullPointerException и ArrayIndexOutOfBoundsException:

String[] array = new String[]{"aaa", null, "ccc"};
for (int i = 0; i < 4; i++) {
    String result = Optional.ofNullable(array.length > i ? array[i] : null)
            .map(x -> x.toUpperCase()) //some operation here
            .orElse("NO_DATA");
    System.out.println(result);
}

Выход:

AAA
NO_DATA
CCC
NO_DATA

Ответ 25

Вы не могли перебирать или хранить больше данных, чем длина вашего массива. В этом случае вы можете сделать следующее:

for (int i = 0; i <= name.length - 1; i++) {
    // ....
}

Или это:

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

Ответ 26

В этом разделе вы получаете доступ к элементам вне цикла:

for(int i=0; i<list.size; i++)
{

}

В этом случае цикл цикла For завершен, и вы снова получаете значение из списка с помощью i++: для получения ArrayindexOutOfBoundexception.

Было бы лучше пойти с циклом ForEach - где все эти проблемы будут заботиться:

for(String str : list)
{
}