是什么导致了 java.lang.ArrayIndexOutOfBoundsException 以及如何防止它？

Question

ArrayIndexOutOfBoundsException 是什么意思以及如何摆脱它？

下面是触发异常的代码示例：

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

Answer 1

您的第一个调用端口应该是文档这解释得相当清楚：

抛出此异常表示已使用非法索引访问了数组。索引可以为负数，也可以大于或等于数组的大小。

例如：

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（包括 0-4）。这里正确、惯用的 for 语句是：（

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

当然，这是假设您需要索引。如果您可以使用增强的 for 循环，那就这样做。）

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

在您的具体情况下，

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

索引包含数组的长度。这是越界的。您需要将 <= 替换为 <。

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

另请参阅：

• Java 教程 - 语言基础知识 - 数组

Answer 3

简而言之：

在 i的最后一次迭代中，

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

将等于 name.length，这是一个非法索引，因为数组索引是从零开始的。

你的代码应该是这样的

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

Answer 4

这意味着您正在尝试访问无效的数组索引，因为它不在边界之间。

例如，这将初始化一个上限为 4 的原始整数数组。

int intArray[] = new int[5];

程序员从零开始计数。例如，由于上限是 4 而不是 5，因此会抛出 ArrayIndexOutOfBoundsException。

intArray[5];

Answer 5

什么原因导致ArrayIndexOutOfBoundsException？

如果您将变量视为可以在其中放置值的“盒子”，那么数组就是一系列彼此相邻放置的盒子，其中盒子的数量是有限且显式的整数。

创建一个像这样的数组：

final int[] myArray = new int[5]

创建一行 5 个框，每个框保存一个 int。每个盒子都有一个索引，即一系列盒子中的位置。该索引从 0 开始，到 N-1 结束，其中 N 是数组的大小（框的数量）。

要从这一系列框中检索其中一个值，您可以通过其索引引用它，如下所示：

myArray[3]

这将为您提供该系列中第四个框的值（因为第一个框的索引为 0）。

ArrayIndexOutOfBoundsException 是由于尝试通过传递高于最后一个“框”索引或负数的索引来检索不存在的“框”而引起的。

以我的运行示例为例，这些代码片段会产生这样的异常：

myArray[5] //tries to retrieve the 6th "box" when there is only 5
myArray[-1] //just makes no sense
myArray[1337] //way 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];
}

Answer 6

为了避免数组索引越界异常，应该使用 增强型-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");
}

Answer 7

在您的代码中，您已访问从索引 0 到字符串数组长度的元素。 name.length 给出字符串对象数组中字符串对象的数量，即 3，但您最多只能访问索引 2 name[2]，
因为可以从索引 0 到 name.length - 1 访问该数组，您可以在其中获取 name.length 对象数量。

即使在使用 for 循环时，您也以索引零开始，并且应该以 name.length - 1 结束。在数组 a[n] 中，您可以访问从 a[0] 到 a[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');
}

Answer 8

对于给定的数组，数组的长度为 3（即 name.length = 3）。但由于它存储从索引 0 开始的元素，因此它的最大索引为 2。

因此，您应该编写“i<**name.length”，而不是“i**<=name.length” '以避免'ArrayIndexOutOfBoundsException'。

Answer 9

这个简单的问题就讲这么多，但我只是想强调一下 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

Answer 10

我见过的看似神秘的 ArrayIndexOutOfBoundsExceptions 最常见的情况（即显然不是由您自己的数组处理代码引起的）是并发使用 SimpleDateFormat。特别是在 servlet 或控制器中：

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

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

如果两个线程一起进入 SimpleDateFormat.parse() 方法，您可能会看到 ArrayIndexOutOfBoundsException。请注意 SimpleDateFormat 类 javadoc。

确保代码中没有任何位置以并发方式（如 Servlet 或控制器中那样）访问线程不安全类（例如 SimpleDateFormat）。检查 servlet 和控制器的所有实例变量是否存在可疑之处。

Answer 11

由于 i<=name.length 部分，您将收到 ArrayIndexOutOfBoundsException 。 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，其中包含组件的数量
数组的。 长度可以是正数或零。

Answer 12

这就是这种类型的异常在 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 中的数组教程

Answer 13

对于多维数组，确保访问正确维度的 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 与 a[j].length 相同）。

相反，内部循环应使用 a[i][j].length （或为简单起见，使用 a[0][0].length）。

Answer 14

ArrayIndexOutOfBoundsException 意味着您正在尝试访问不存在或超出该数组范围的数组索引。数组索引从 0 开始，到 length - 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
}

Answer 15

对于任何长度为 n 的数组，数组元素的索引范围为 0 到 n-1。

如果您的程序尝试访问数组索引大于 n-1 的任何元素（或内存） ，那么Java会抛出ArrayIndexOutOfBoundsException

所以这里有两个我们可以在程序中使用的解决方案

1. 维护计数：

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

   或者其他一些循环语句，例如

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

2. 更好的方法是使用 foreach 循环，在这种方法中，程序员无需担心数组中元素的数量。< /p>

   for(String str : array) {
       System.out.println(str);
   }
   

Answer 16

ArrayIndexOutOfBoundsException 每当出现此异常时，都意味着您正在尝试使用超出其范围的数组索引，或者用外行术语来说，您请求的索引超出了初始化的索引。

为了防止这种情况，请始终确保您请求的索引不存在于数组中，即如果数组长度为 10，则索引范围必须在 0 到 9 之间

Answer 17

ArrayIndexOutOfBounds 意味着您正在尝试索引数组中未分配的位置。

在本例中：

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

• name.length 为 3，因为该数组已使用 3 个 String 对象定义。
• 当访问数组的内容时，position从0开始。由于有3个项目，因此
• 当你循环时， 这意味着name[0]=“tom”，name[1]=“dick”和name[2]=“harry” ，由于 i 可以小于或等于 name.length，因此您正在尝试访问不可用的 name[3]

要解决此问题...

• 在 for 循环中，你可以这样做 i < name.length. 这将阻止循环到 name[3] 并停止在 name[2]

  for(int i = 0; i

• 每个循环使用一个 for p>

  String[] name = { "tom", "dick", "harry" };
for(字符串 n : 名称) {
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);

Answer 18

根据您的代码：

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

如果您检查
System.out.print(名称.长度);

你会得到 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');
}

Answer 19

数组中的每个项目称为一个元素，每个元素都可以通过其数字索引来访问。如上图所示，编号从 0 开始。例如，第 9 个元素将在索引 8 处访问。

抛出 IndexOutOfBoundsException 表示某种索引（例如数组、字符串或向量）超出范围。

任何数组X，可以从[0到(X.length - 1)]访问

Answer 20

我在这里看到所有答案解释如何使用数组以及如何避免索引越界异常。我个人不惜一切代价避免使用数组。我使用 Collections 类，它避免了必须完全处理数组索引的所有愚蠢行为。循环结构与支持代码的集合完美配合，更易于编写、理解和维护。

Answer 21

ArrayIndexOutOfBoundsException 名称本身说明，如果您尝试访问超出数组大小范围的索引处的值，则会发生此类异常。

在你的情况下，你可以从 for 循环中删除等号。

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

更好的选择是迭代数组：

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

Answer 22

如果您使用数组的长度来控制 for 循环的迭代，请始终记住数组中第一项的索引是 0。因此数组中最后一个元素的索引比数组的长度小一。

Answer 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”。然后，使用 for 循环打印一些数组元素。当循环运行'i'次时，打印(numberArray[i+1]元素..(当i值为1时，打印numberArray[i+1]元素。)..假设，当i=(numberArray. length-2)，打印数组的最后一个元素。当“i”值转到(numberArray.length-1)时，没有打印值。此时，会发生“ArrayIndexOutOfBoundsException”。我希望你能得到想法。谢谢！

Answer 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

Answer 25

当您尝试访问不存在的数组的索引时，会发生 ArrayIdexOutOfBoundException。在您的场景中，当 i = 3 时，您尝试检索名称数组的第三个索引。但名称数组保存的值最多为第二个索引。

由于数组的第三个索引处没有值，因此抛出此异常。