Когда вы объявляете ссылочную переменную (т. е. объект), вы действительно создаете указатель на объект. Рассмотрим следующий код, в котором вы объявляете переменную примитивного типа int
:
int x;
x = 10;
В этом примере переменная x является int
, и Java инициализирует ее для 0. Когда вы назначаете его 10 во второй строке, ваше значение 10 записывается в ячейку памяти, на которую указывает x.
Но когда вы пытаетесь объявить ссылочный тип, произойдет что-то другое. Возьмите следующий код:
Integer num;
num = new Integer(10);
Первая строка объявляет переменную с именем num
, но она не содержит примитивного значения. Вместо этого он содержит указатель (потому что тип Integer
является ссылочным типом). Поскольку вы еще не указали, что указать на Java, он устанавливает значение null, что означает «Я ничего не указываю».
Во второй строке ключевое слово new
используется для создания экземпляра (или создания ) объекту типа Integer и переменной указателя num
присваивается этот объект. Теперь вы можете ссылаться на объект, используя оператор разыменования .
(точка).
Exception
, о котором вы просили, возникает, когда вы объявляете переменную, но не создавали объект. Если вы попытаетесь разыменовать num
. Перед созданием объекта вы получите NullPointerException
. В самых тривиальных случаях компилятор поймает проблему и сообщит вам, что «num не может быть инициализирован», но иногда вы пишете код, который непосредственно не создает объект.
Например, вы можете имеют следующий метод:
public void doSomething(SomeObject obj) {
//do something to obj
}
В этом случае вы не создаете объект obj
, скорее предполагая, что он был создан до вызова метода doSomething
. К сожалению, этот метод можно вызвать следующим образом:
doSomething(null);
В этом случае obj
имеет значение null. Если метод предназначен для того, чтобы что-то сделать для переданного объекта, целесообразно бросить NullPointerException
, потому что это ошибка программиста, и программисту понадобится эта информация для целей отладки.
Альтернативно, там могут быть случаи, когда цель метода заключается не только в том, чтобы работать с переданным в объекте, и поэтому нулевой параметр может быть приемлемым. В этом случае вам нужно будет проверить нулевой параметр и вести себя по-другому. Вы также должны объяснить это в документации. Например, doSomething
может быть записано как:
/**
* @param obj An optional foo for ____. May be null, in which case
* the result will be ____.
*/
public void doSomething(SomeObject obj) {
if(obj != null) {
//do something
} else {
//do something else
}
}
Наконец, Как определить исключение & amp; причина использования Трассировки стека
Ваш первый порт вызова должен быть документацией , который объясняет это разумно ясно:
Брошено, чтобы указать, что к массиву был обращен незаконный индекс. Индекс является либо отрицательным, либо большим или равным размеру массива.
Так, например:
int[] array = new int[5]; int boom = array[10]; // Throws the exception
Как избежать этого. ., не делайте этого. Будьте осторожны с вашими индексами массива.
Одной из проблем, с которыми иногда сталкиваются люди, является то, что массивы 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++)
(Предполагается, что вы нуждаетесь в индексе, конечно. Если вы можете использовать расширенный для цикла, сделайте это.)
Согласно вашему коду:
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');
}
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
происходит, когда вы пытаетесь получить доступ к элементу index.length, который делает не существует (индекс массива заканчивается на -1). просто заменяя & lt; = с & lt; решит эту проблему.
for(int i = 0; i < name.length; i++) {
System.out.print(name[i] +'\n'); // i goes from 0 to length - 1, Correct
}
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];
}
Обновление: в соответствии с вашим фрагментом кода,
for(int i = 0; i<=name.length; i++) {
Индекс содержит длину массива. Это за гранью. Вы должны заменить <=
на <
.
for(int i = 0; i < name.length; i++) {
Для многомерных массивов может быть сложно получить доступ к свойству 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
той же размерности (поскольку a[i].length
(f5)).
Вместо этого внутренний цикл должен использовать a[i][j].length
(или a[0][0].length
для простоты).
Эта ошибка возникает при переполнении циклов цикла. Давайте рассмотрим простой пример:
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] .. (когда значение i равно 1, будет напечатан элемент numberArray [i + 1].) Предположим, что, когда i = (numberArray. length-2), последний элемент массива печатается. Когда значение «i» переходит к (numberArray.length-1), нет значения для печати. В этот момент происходит «ArrayIndexOutOfBoundsException». Я надеюсь, что вы можете получить idea.thank you!
Чтобы исключить исключительное исключение индекса массива, следует использовать инструкцию расширенный- 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");
}
Для вашего массива длина массива равна 3 (например, name.length = 3). Но поскольку он хранит элемент, начинающийся с индекса 0, он имеет максимальный индекс 2.
Итак, вместо 'i ** & lt; = name.length' вы должны написать 'i & lt; ** name.length' чтобы избежать «ArrayIndexOutOfBoundsException».
Это означает, что вы пытаетесь получить доступ к индексу массива, который недопустим, поскольку он не находится между границами.
Например, это инициализировало бы примитивный целочисленный массив с верхней границей 4 .
int intArray[] = new int[5];
Программисты подсчитываются с нуля. Таким образом, это, например, выбрало бы ArrayIndexOutOfBoundsException
, поскольку верхняя граница равна 4, а не 5.
intArray[5];
Вы не могли итерировать или хранить больше данных, чем длина вашего массива. В этом случае вы можете сделать так:
for (int i = 0; i <= name.length - 1; i++) {
// ....
}
Или это:
for (int i = 0; i < name.length; i++) {
// ...
}
Так много для этого простого вопроса, но я просто хотел выделить новую функцию на 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
ArrayIndexOutOfBoundsException
само имя объясняет, что если вы пытаетесь получить доступ к значению в индексе, который выходит за рамки размера массива, возникает такое исключение.
В вашем случае вы можете просто удалить знак равенства из цикла for.
for(int i = 0; i<name.length; i++)
Лучшим вариантом является итерация массива:
for(String i : name )
System.out.println(i);
Короче говоря:
В последней итерации
for(int i = 0; i<=name.length; i++) {
i
будет равно name.length
, что является незаконным индексом, так как индексы массива равны нулю, основанный.
Ваш код должен читать
for(int i = 0; i < name.length; i++)
^
Что вызывает ArrayIndexOutOfBoundsException
?
Если вы думаете о переменной как о «поле», где вы можете поместить значение, то массив представляет собой ряд ящиков, расположенных рядом с eachother, где число Ячейки представляют собой конечное и явное целое число.
Создание такого массива:
final int[] myArray = new int[5]
создает строку из 5 полей, каждая из которых имеет int
. Каждый из ящиков имеет индекс, позицию в ряду ящиков. Этот индекс начинается с 0 и заканчивается на N-1, где N - размер массива (количество ящиков).
Чтобы получить одно из значений из этой серии ящиков, вы можете обратиться к нему через его индекс, например:
myArray[3]
Который даст вам значение 4-го ящика в серии (так как в первом поле есть индекс 0).
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
, необходимо рассмотреть некоторые ключевые моменты:
Looping
При переходе по массиву всегда убедитесь, что индекс, который вы извлекаете, строго меньше длины массива (количество ящиков). Например:
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
). Единственное место, которое должно изменить значение, это сохранить цикл. Изменение в противном случае просто рискует исключением и в большинстве случаев не является обязательным.
Retrieval / update
При извлечении произвольного элемента массива всегда проверяйте его действительность индекс по длине массива:
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];
}
for (int nestedIndex = 0; nestedIndex < array[outerIndex].length; nestedIndex++) { ... array[outerIndex][nestedIndex] ... }
. – Andrey 2 March 2017 в 23:04