首页 > 编程笔记 > Java笔记 阅读：175

Java 数组（一维数组和二维数组）的用法

通义灵码
单个变量只能存储一个数据，为了方便存储一组同一数据类型的多个数据，和绝大部分计算机语言一样，Java 提供了数组。

在 Java 中较为常用的数组是一维数组和二维数组，将数组和循环结构相结合可以解决许多复杂的问题。

一维数组

一维数组是一种线性数组，访问一维数组中的元素涉及单个下标，它可以表示行索引或列索引。

一维数组的示意图如下：


图 1 一维数组的示意图

1) 一维数组的声明

声明一维数组的语法格式如下： 
数据类型[] 数组名;
数据类型 数组名[];
从面向对象的角度来看，推荐采用第一种声明方式，因为它把“元素数据类型[]”看成一个整体类型，即数组类型。

这里需要注意的是，数组不是基本数据类型而是引用类型。即使是用于存储基本数据类型数据的数组，本身的数据类型也是引用类型。

2) 一维数组的创建（动态初始化）

数组声明完成后，数组的长度还不能确定，Java 虚拟机还没有为元素分配内存空间。数组的创建过程，就是 Java 虚拟机在堆空间（Heap）中为数组元素分配内存空间并返回地址的过程。

动态初始化就是使用 new 运算符分配指定长度的内存空间，语法格式如下：
数组名 = new 数组元素类型[元素个数];
需要注意的是，数组的声明和内存空间的分配可以在声明时同时完成，例如： 
  1. int[] arr = new int[4]; // 创建一个长度为 4 个数组

3) 数组的静态初始化

可以在声明一个数组的同时对数组中的每个元素进行赋值，语法格式如下：
数据类型[] 数组名 = {初值表};
例如： 
  1. int[] arr = {1,2,3,4};
也可以将声明和初始化过程分开进行，例如： 
  1. int[] arr;
  2. arr = new int[]{1,2,3,4}; // ①
注意，① 处的语句不可以写成arr={1,2,3,4};。

4) 数组元素的初始化

在创建数组时，Java 虚拟机会根据数组元素的类型自动赋初值：
例如： 
  1. int[] arr = new int[4]; //{0,0,0,0}

5) 一维数组的长度

一维数组中元素的个数称为数组的长度。对于一维数组，“数组名.length”的值就是数组中元素的个数。

例如： 
  1. float[] a = new float[10]; // a.length 的值为 10

6) 一维数组的访问

对一个数组中的元素进行访问是通过数组的下标实现的。下标是数组为其中的元素默认提供的访问索引。

在 Java 中，数组的下标从 0 开始，长度为 n 的数组的下标合法的取值范围为 0~n-1。在程序运行过程中，如果数组的下标超过这个范围就会抛出下标越界异常，即 IndexOutOfBoundsException。

例如： 
  1. int[] arr = new int[4]; // 创建一个长度为4的整型数组 
  2. System.out.println(arr[0]); // 读取数组中下标为0的元素的值，输出结果为0 
  3. arr[0] = 5; // 为数组中下标为0的元素赋值 
  4. System.out.println(arr[0]); // 再次读取数组中下标为0的元素的值，输出结果为5

【实例】一维数组的应用。 
  1. public class Test { 
  2.     public static void main(String[] args) { 
  3.         // 0, 0, 0, 0 
  4.         int[] arr = new int[4]; 
  5.         System.out.println(arr[0]);
  6.         arr[0] = 8; 
  7.         arr[1] = 10; 
  8.         arr[2] = 30; 
  9.         arr[3] = 100; 
  10.  
  11.         // arr[4] = 10; // 这行会导致 ArrayIndexOutOfBoundsException 异常，因为数组下标是从0到3 
  12.  
  13.         System.out.println(arr[0]); // 输出：8 
  14.         System.out.println(arr[1]); // 输出：10 
  15.         System.out.println(arr[2]); // 输出：30 
  16.         System.out.println(arr[3]); // 输出：100 
  17.  
  18.         // 数组相当于存储了一组变量，每个元素都是一个变量 
  19.         int n = arr[2] + arr[1] * 10; 
  20.         System.out.println(n); // 输出：310 (30 + 10 * 10) 
  21.  
  22.         System.out.println(arr.length); // 输出：4，利用length可以读取数组的长度 
  23.  
  24.         double[] arr1 = new double[3]; 
  25.  
  26.         System.out.println(arr1[0]);
  27.  
  28.         arr1[0] = 35.0; 
  29.         System.out.println(arr1[0]); // 输出：35.0 
  30.  
  31.         // 使用已知数据直接初始化数组中的元素 
  32.         int[] arr2 = new int[]{9, 19, 23, 65, 8}; 
  33.  
  34.         System.out.println(arr2[2]); // 输出：23 
  35.  
  36.         // 简写形式：只能在声明数组的同时进行初始化 
  37.         int[] arr3 = {9, 19, 23, 65, 8}; 
  38.  
  39.         // 声明后必须初始化才能使用 
  40.         int[] arr4; 
  41.         // arr4 = { 5, 2 , 4 , 5 }; // 编译错误，不能在声明后单独初始化 
  42.         arr4 = new int[]{5, 2, 4, 5}; // 正确的初始化方式 
  43.  
  44.         // 字符数组 
  45.         char[] chars = new char[5];
  46.         // 编号为 0 的字符是控制字符，输出基本没有效果 
  47.         System.out.println(chars[0]);
  48.         // 转换为int型值输出，结果为字符'\u0000'的ASCII码值，即0 
  49.         System.out.println((int)chars[0]); // 输出：0 
  50.     } 
  51. }
输出结果为：

0
8
10
30
100
130
4
0.0
35.0
23

0

7) 数组的遍历

数组的遍历是指按照特定的顺序访问数组中的全部元素，这是数组使用中的一类特别常见的操作。

例如，遍历数组中的元素，查找满足特定条件的元素。数组的遍历一般是通过循环实现的，如 for 循环。

【实例】使用 for 循环遍历数组。 
  1. public class Test { 
  2.     public static void main(String[] args) { 
  3.         int[] array = new int[100]; 
  4.  
  5.         // 将数组中的元素设为1到100 
  6.         for (int i = 0; i < array.length; i++) {
  7.             array[i] = i + 1; 
  8.         } 
  9.  
  10.         // 输出数组中所有13的倍数 
  11.         for (int i = 0; i < array.length; i++) { 
  12.             if (array[i] % 13 == 0) { 
  13.                 System.out.print(array[i] + " ");
  14.                 // 13 26 39 52 65 78 91 
  15.             } 
  16.         } 
  17.     } 
  18. }
输出结果为：

13 26 39 52 65 78 91

二维数组

当数组中的元素也是一维数组时，将该数组称为二维数组，示意图如下：


图 2 二维数组的示意图

二维数组的每行的元素个数可能不同，所以也称为锯齿数组。

1) 二维数组的声明

声明二维数组的语法格式如下： 
数据类型[][] 数组名;
数据类型 数组名[][];

2) 二维数组的创建（动态初始化）

创建二维数组的语法格式如下： 
数组名 = new 数据类型[元素个数][];
例如： 
  1. // 声明二维数组时至少要给出第一维的长度，即确定行数
  2. // 每行元素的个数还不确定
  3. int[][] ia = new int[3][];
  4.  
  5. // 创建一个 3 行 4 列的二维数组
  6. int[][] ib = new int[3][4];

3) 数组元素的初始化

和一维数组一样，在创建二维数组时 Java 虚拟机会根据数组元素的类型自动赋初值。

例如： 
  1. int[][] ia = new int[3][];  // {null, null, null}
  2. int[][] ib = new int[3][2]; // {{0,0},{0,0},{0,0}}

4) 二维数组的创建（静态初始化）

创建二维数组的语法格式如下： 
数据类型 数组名[][] = {{初值表}, {初值表}};

例如： 
  1. int[][] a = {{1,2,3,4},{5,6},{7,8,9}};

5) 二维数组的长度

length 是数组的一个属性，用来表示数组的长度。但对于二维数组来说，“数组名.length”的值是它包含的一维数组的个数。例如： 
  1. int[][] b = new int[2][5]; // 创建一个二维数组，外层数组长度为2，内层数组长度为5 
  2. // 输出外层数组的长度，即二维数组的行数 
  3. System.out.println(b.length); // 输出2 
  4. // 输出内层数组的长度，即二维数组的列数（假设所有内层数组长度相同） 
  5. System.out.println(b[0].length); // 输出5

6) 二维数组的访问

通过“数组名[行下标][列下标]”的方式来访问二维数组的元素。例如，a.length 代表行数，a[i].length 代表第 i 行的元素的个数。

使用二重循环遍历二维数组的程序片段如下所示： 
  1. int[][] a = {{14, 22, 35, 42}, {15, 67, 45}, {16, 34}};  
  2. for (int i = 0; i < a.length; i++) { 
  3.     for (int j = 0; j < a[i].length; j++) { 
  4.         System.out.print(a[i][j] + " ");
  5.     } 
  6.     System.out.println();
  7. }

相关文章