数组可以解决一个很实际的问题:当我们需要保存一批同类型的数据时,总不能为每个值都单独定义一个变量。

比如,一个班有 40 位学生,要记录他们的成绩。如果依次定义 40 个变量,写起来麻烦,后面查找和处理这些成绩也不方便。这时就可以使用数组。

认识数组

数组是一种容器,可以用来存储多个相同类型的值。 比如,int[] 可以保存一组整数,String[] 可以保存一组字符串。

数组存储元素时,也要遵守 Java 的类型转换规则。例如,int 数组不能直接存入带有小数部分的 double 值;但 double 数组可以存入 int 值,因为 int 可以通过自动类型转换变成 double。实际使用时,通常根据需要保存的数据选择合适的数组类型。

数组的定义

数组有两种常见的声明写法:

java
int[] array;
int array[];

这两种写法都能声明一个 int 数组变量,但更推荐第一种 int[] array,因为它能更直观地看出变量的类型是 int[]。

这里只是声明了数组变量,并没有创建数组对象。想要真正存储数据,还需要初始化数组。

数组的两种初始化方式

初始化可以理解为:创建数组,分配用于存储元素的空间,并为各个位置设置初始值。 Java 中常用的方式有静态初始化和动态初始化。

静态初始化:已经知道要存哪些数据

如果创建数组时就知道具体有哪些元素,可以使用静态初始化。

完整格式:

纯文本
数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3};

例如:

java
int[] array = new int[]{11, 22, 33};

在声明数组的同时初始化时,也可以省略 new int[],写得更简洁:

java
int[] array = {11, 22, 33};

下面再分别定义一个整数数组和一个字符串数组:

java
public class Test1 {
    public static void main(String[] args) {
        int[] array = { 1, 2, 3, 4, 5 };
        String[] s = { "hello", "world", "hi" };
    }
}

数组创建后,长度就固定了。这个简写形式只适用于声明时直接初始化;如果是先声明、再赋值,仍要写 new int[]{...}。比如 {11, 22, 33} 一共有 3 个元素,数组长度就是 3,不能直接再增加第四个位置。不过,已有位置上的值仍然可以修改。

动态初始化:先确定长度,数据以后再填

那如果暂时不知道数组里具体要存什么数据呢?比如要录入全班 40 位同学的成绩,我们知道人数是 40,但还不知道每个人的分数。

这时就可以使用动态初始化:先指定长度,由 Java 给每个位置填入默认值,等拿到实际成绩后再修改对应元素。

格式:

纯文本
数据类型[] 数组名 = new 数据类型[数组长度];

例如 int[] array = new int[3];,表示创建一个长度为 3 的整数数组。下面用班级成绩的例子来看看:

java
public class Test1 {
    public static void main(String[] args) {
        int[] score = new int[40];
        score[0] = 66;
        score[1] = 73;
        System.out.println(score[0]);//66
        System.out.println(score[1]);//73
        System.out.println(score[2]);//0
    }
}

这里创建了一个长度为 40 的整数数组,然后只给前两个位置赋了值。score[2] 还没修改,打印出来就是 0,这是因为 int 数组中的元素默认初始化为 0。

不同类型数组的默认值

动态初始化时,数组元素会先得到与其类型对应的默认值:

元素类型默认值
byte、short、int、long0
float、double0.0
char\u0000(空字符,不是空格)
booleanfalse
引用类型,如 Stringnull

其中,char 的默认值 \u0000 是 Unicode 编码为 0 的字符,不是我们输入文字时按空格键得到的 ' '。

两种方式的区别其实很好记:静态初始化是指定元素,让系统确定数组长度;动态初始化是指定长度,让系统设置默认值。知道要保存哪些值时,通常用静态初始化;先知道需要多少个位置、内容后续再录入时,动态初始化更合适。

数组元素的访问与修改

直接打印数组变量,会得到什么?

数组创建好了,该怎么拿到里面的值呢?先试着直接打印数组变量:

java
public class Test1 {
    public static void main(String[] args) {
        int[] array = { 1, 2, 3, 4, 5,6 };
        System.out.println(array);//[I@14dad5dc
    }
}

你可能会看到类似 [I@14dad5dc 的内容。这不是数组里的 1、2、3……,也不是可以直接拿来使用的真实内存地址。

它来自数组对象默认的字符串表示形式,可以简单拆开理解:[I 表示 int 数组类型,@ 后面是对象哈希码的十六进制表示。代码注释中的输出只是一次运行的示例,不同运行或不同对象不保证得到相同的字符串。

所以,要取得数组里具体的元素,不能只打印数组变量名,而要通过索引来访问。

使用索引访问元素

格式:数组名[索引]

索引也叫下标或角标,从 0 开始,依次增加 1。这和我们平时数“第一个、第二个、第三个”不太一样:数组中的“第一个”对应索引 0,“第三个”对应索引 2。

java
public class Test1 {
    public static void main(String[] args) {
        int[] array = { 1, 2, 3, 4, 5, 6 };
        System.out.println(array[2]);// 3
    }
}

这里的 array[2] 取到的就是第三个元素,因此打印结果为 3。

修改指定位置的值

访问元素后,还可以直接给这个位置重新赋值,格式为 数组名[索引] = 新值;,和修改普通变量的写法很相似。

java
public class Test1 {
    public static void main(String[] args) {
        int[] array = { 1, 2, 3, 4, 5, 6 };
        System.out.println(array[2]);// 3
        array[2] = 66;
        System.out.println(array[2]);//66
    }
}

先打印 array[2],得到 3;再执行 array[2] = 66,这个位置原来保存的 3 就被 66 覆盖了。因此第二次打印的结果变成 66。

数组遍历

遍历就是依次访问数组中的元素,并根据需要对它们进行处理。 处理可以是打印、求和、判断条件等,不能把“遍历”简单理解为“打印”。

使用 for 循环遍历

数组索引从 0 开始,又是连续递增的,很适合结合 for 循环来访问。但循环到底要执行多少次呢?

如果数组里只有 6 个元素,直接看代码就知道;可要是里面有几百个元素,总不能一个一个数。这时可以使用数组的 length 属性获取长度,写法是 数组名.length。

java
public class Test1 {
    public static void main(String[] args) {
        int[] array = { 1, 2, 3, 4, 5, 6 };
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

这里 array.length 为 6,循环中的 i 依次取 0、1、2、3、4、5,正好访问数组的全部 6 个元素。当 i 增加到 6 时,不满足 i < array.length,循环结束。

遍历时对元素求和

遍历当然不只是为了打印。例如,想计算数组里所有元素的总和,可以先定义一个变量 sum,每遍历到一个元素,就把它加到 sum 上。

java
public class Test1 {
    public static void main(String[] args) {
        int[] array = { 1, 2, 3, 4, 5, 6 };
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        System.out.println(sum);
    }
}

从 sum = 0 开始,每次执行 sum += array[i],最终得到 1 + 2 + 3 + 4 + 5 + 6 = 21,最后再打印 sum 就可以了。

数组常见问题:索引越界

数组的长度是固定的,有效索引范围是 0 到 数组长度 - 1。如果访问了这个范围之外的位置,就会发生数组索引越界。

java
public class Test1 {
    public static void main(String[] args) {
        int[] array = new int[3];
        System.out.println(array[3]);
    }
}

这段代码创建了一个长度为 3 的数组,合法索引只有 0、1、2。访问 array[3] 时,代码虽然可以编译,但运行到这一句会抛出 ArrayIndexOutOfBoundsException。

示例报错信息:

Shell
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
        at Test1.main(Test1.java:4)

报错中的 Index 3 out of bounds for length 3,说明访问的索引是 3,而数组长度只有 3。以后遇到类似报错,可以先检查访问的索引是否小于 0,或者是否已经达到数组长度。

Java 内存分配

前面一直在创建和操作数组,那么数组在内存中到底存在哪里呢?这里先简单了解一下 Java 运行时的几个主要内存区域:

  • 栈:方法运行时会用到的内存。例如执行 main 方法时,会用栈帧保存方法中的局部变量等信息。
  • 堆:主要存放对象和数组。我们用 new 创建的数组,通常就在堆中。
  • 方法区:与类的信息有关,可以先简单理解为存放类相关信息的区域。
  • 本地方法栈:与本地方法的调用有关,初学阶段了解即可。
  • 寄存器(程序计数器):用于记录线程当前执行的位置,先了解即可。

下面是 JDK 8 之前的简化示意图:

JDK 8 之前的内存区域(简化示意)
本地方法栈
寄存器
栈
方法区
堆

从 JDK 8 开始,我们可以先简单理解为:原来图中画在“方法区”位置的一部分内容,改由堆和元空间保存,因此常见的入门示意图会用“元空间”替换原来的那个方块。

JDK 8 及之后的内存区域(简化示意)
本地方法栈
寄存器
栈
元空间
堆

这里两张图只是为了方便理解的简化示意,不代表真实的内存布局,也不表示 JVM 规范中的“方法区”这个概念被取消。现在先知道这些区域和示意图的变化即可。

数组与栈、堆的关系

结合前面的数组代码,我们目前只需要记住:在 main 方法中定义的局部变量 array,保存的是访问数组对象的引用;数组对象本身通常存储在堆中。

所以,数组变量和数组对象并不是一回事。访问数组中的具体数据,仍然要通过 array[0]、array[1] 这样的索引来完成。

谢谢你读到这里。 ✧

聊两句

评论审核后显示

有疑问、补充,或者想交流一下,都可以写在这里。

评论区将在滚动到这里时加载。