[Java] 弄懂数组，这一篇就够了

🔥一个人走得远了，就会忘记自己为了什么而出发，希望你可以不忘初心，不要随波逐流，一直走下去🎶
🦋 欢迎关注🖱点赞👍收藏🌟留言🐾
🦄 本文由 程序喵正在路上 原创，CSDN首发！
💖 系列专栏：Java入门
🌠首发时间：2022年4月30日
✅如果觉得博主的文章还不错的话，希望小伙伴们三连支持一下哦

导语

数组（array）是相同类型变量的集合，可以使用共同的名字引用它。数组可被定义为任何类型，可以是一维或多维。数组中的一个特别要素是通过下标来访问它。数组提供了一种将有联系的信息分组的便利方法。

注意：如果你熟悉 C/C++，请注意，Java 数组的工作原理与它们不同。

一维数组

一维数组的定义

一维数组实质上是相同类型变量列表。要创建一个数组，你必须首先定义数组变量所需的类型。通用的一维数组的声明格式是:

type var-name [ ];

其中，type 定义了数组的基本类型。基本类型决定了组成数组的每一个基本元素的数据类型。这样，数组的基本类型决定了数组存储的数据类型。

例如，下面的例子定义了数据类型为 int ，名为 month_days 的数组：

int month_days [ ];

声明一维数组

尽管该例子定义了 month_days 是一个数组变量的事实，但实际上没有数组变量存在。事实上，month_days 的值被设置为空(null)，它代表一个数组没有值。为了使数组 month_days 成为实际的、物理上存在的整型数组，你必须用运算符 new 来为其分配地址并且把它赋给 month_days。运算符 new 是专门用来分配内存的运算符。

当运算符 new 被应用到一维数组时，它的一般形式如下:
array-var =new type [size];

其中，type 指定被分配的数据类型，size 指定数组中变量的个数，array-var 是被链接到数组的数组变量。也就是，使用运算符 new 来分配数组，你必须指定数组元素的类型和数组元素的个数。用运算符 new 分配数组后，数组中的元素将会被自动初始化为零。下面的例子分配了一个 12 个整型元素的数组并把它们和数组 month_days 链接起来。

int[] month_days = new int[12];

通过这个语句的执行，数组 month_days 将会指向 12 个整数，而且数组中的所有元素将被初始化为零。

让我们回顾一下上面的过程：获得一个数组需要 2 步。第一步，你必须定义变量所需的类型。第二步，你必须使用运算符 new 来为数组所要存储的数据分配内存，并把它们分配给数组变量。这样 Java 中的数组被动态地分配。一旦你分配了一个数组，你可以在方括号内指定它的下标来访问数组中特定的元素。

所有的数组下标从零开始。例如，下面的语句将值 28 赋给数组 month_days 的第二个元素。

month_days [1] = 28;

下面的程序显示存储在下标为 3 的数组元素中的值。

System.out.println(month_days[3]);

一维数组的初始化与输出

综上所述，下面程序定义的数组存储了每月的天数。

public class Array {
	public static void main(String[] args) {
		int month_days[];
		month_days = new int[12];
		month_days[0] = 31;
		month_days[1] = 28;
		month_days[2] = 31;
		month_days[3] = 30;
		month_days[4] = 31;
		month_days[5] = 30;
		month_days[6] = 31;
		month_days[7] = 31;
		month_days[8] = 30;
		month_days[9] = 31;
		month_days[10] = 30;
		month_days[11] = 31;
		System.out.println("April has " + month_days[3] + " days.");	
	}
}

程序运行结果如下：

April has 30 days.

当你运行这个程序时，它打印出 4 月份的天数。如前面提到的，Java 数组下标从零开始，因此 4 月份的天数数组元素为 month_days[3] 或 30。

将对数组变量的声明和对数组本身的分配结合起来是可以的，如下所示：

int month_days[] = new int[12];

这将是你通常看见的编写 Java 程序的专业做法。

数组可以在声明时被初始化，这个过程和简单类型初始化的过程一样。数组的初始化就是包括在花括号之内用逗号分开的表达式的列表。逗号分开了数组元素的值。Java 会自动地分配一个足够大的空间来保存你指定的初始化元素的个数，而不必使用运算符 new。

例如，为了存储每月中的天数，下面的程序定义了一个初始化的整数数组：

public class AutoArray {
    public static void main(String args[]) {
        int month_days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        System.out.println("April has " + month_days[3] + " days. ");
    }
}

程序运行结果如下：

April has 30 days.

当你运行这个程序时，你会看到它和前一个程序产生的输出一样。

Java 严格地检查以保证你不会意外地去存储或引用在数组范围以外的值。Java 的运行系统会检查以确保所有的数组下标都在正确的范围以内(在这方面，Java 与 C/C++ 从根本上不同，C/C++ 不提供运行边界检查)。例如，运行系统将检查数组 month_days 的每个下标的值以保证它包括在 0 和 11 之间。如果你企图访问数组边界以外(负数或比数组边界大)的元素，你将引起运行错误。

下面我们运用一维数组来计算一组数字的平均数。

public class Average{
    public static void main(String args[]) {
        double nums[] = {10.1, 11.2, 12.3, 13.4, 14.5};
        double result = 0;
        int i;

        for (i = 0; i < 5; i++) {
            result += nums[i];
        }

        System.out.println("Average is " + result / nums.length + ".");
    }
}

程序运行结果如下：

Average is 12.299999999999999.

多维数组

多维数组的定义

在 Java 中，多维数组实际上是数组的数组。你可能期望，这些数组形式上和行动上和一般的多维数组一样。然而，你将看到，有一些微妙的差别。定义多维数组变量要将每个维数放在它们各自的方括号中。例如，下面语句定义了一个名为 twoD 的二维数组变量。

int twoD[][] = new int[4][5];

该语句分配了一个 4 行 5 列的数组并把它分配给数组 twoD。实际上这个矩阵表示了 int 类型的数组的数组被实现的过程。

多维数组的初始化

下列程序从左到右，从上到下为数组的每个元素赋值，然后显示数组的值:

public class TwoDArray {
    public static void main(String args[]) {
        int twoD[][] = new int[4][5];
        int i, j, k = 0;

        //遍历赋值
        for (i = 0; i < 4; i++) {
            for (j = 0; j < 5; j++) {
                twoD[i][j] = k;
                k++;
            }
        }
        
        //遍历输出
        for (i = 0; i < 4; i++) {
            for (j = 0; j < 5; j++) {
                System.out.print(twoD[i][j] + " ");
            }
            System.out.println();
        }
    }
}

程序运行结果如下：

0  1  2  3  4
5  6  7  8  9
10  11  12  13  14
15  16  17  18  19

当你给多维数组分配内存时，你只需指定第一个（最左边）维数的内存即可。你可以单独地给余下的维数分配内存。例如，下面的程序在数组 twoD 被定义时给它的第一个维数分配内存，对第二维则是手工分配地址。

int twoD[][] = new int[4][];
twoD[0] = new int[5];
twoD[2] = new int[5];
twoD[3] = new int[5];
twoD[4] = new int[5];

尽管在这种情形下单独地给第二维分配内存没有什么优点，但在其他情形下就不同了。

比如，当你手工分配内存时，你不需要给每个维数相同数量的元素分配内存。如前面所说，既然多维数组实际上是数组的数组，每个数组的维数在你的控制之下。

不规则二维数组

例如，下列程序定义了一个二维数组，它的第二维的大小是不相等的。

public class TwoDAgain {
    public static void main(String args[]) {
        int twoD[][] = new int[4][];
        twoD[0] = new int[1];
        twoD[1] = new int[2];
        twoD[2] = new int[3];
        twoD[3] = new int[4];
        int i, j, k = 0;

		// 遍历初始化数组
        for (i = 0; i < 4; i++) {
            for (j = 0; j < i + 1; j++) {
                twoD[i][j] = k;
                k++;
            }
        }

		// 遍历输出数组
        for (i = 0; i < 4; i++) {
            for (j = 0; j < i + 1; j++) {
                System.out.print(twoD[i][j] + " ");
            }
            System.out.println();
        }
    }
}

程序运行结果如下：

0
1  2
3  4  5
6  7  8  9

对于大多数应用程序，我们不推荐使用不规则多维数组，因为它们的运行与人们的期望相反。但是，不规则多维数组在某些情况下使用效率较高。

例如，如果你需要一一个很大的二维数组，而它仅仅被稀疏地占用( 即其中一维的元素不是全被使用)，这时不规则数组可能是一个完美的解决方案。

初始化多维数组是可能的。初始化多维数组只不过是把每一维的初始化列表用它自己的大括号括起来即可。下面的程序产生一个矩阵，该矩阵的每个元素包括数组下标的行和列的积。同时注意在数组的初始化中你可以像用字面量一样用表达式。

public class Matrix {
    public static void main(String args[]) {
        // 初始化数组
        double m[][] = {
                {0 * 0, 1 * 0, 2 * 0, 3 * 0},
                {0 * 1, 1 * 1, 2 * 1, 3 * 1},
                {0 * 2, 1 * 2, 2 * 2, 3 * 2},
                {0 * 3, 1 * 3, 2 * 3, 3 * 3}
        };

        // 遍历输出数组
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.print(m[i][j] + " ");
            }
            System.out.println();
        }
    }
}

程序运行结果如下：

0.0  0.0  0.0  0.0
0.0  1.0  2.0  3.0
0.0  2.0  4.0  6.0
0.0  3.0  6.0  9.0

正如你看到，数组中的每一行就像初始化表指定的那样被初始化。

三维数组

让我们再来看一个使用多维数组的例子。
下面的程序首先产生一个 3×4×5 的 3 维数组，然后装入用它的下标之积生成的每个元素，最后显示了该数组。

public class threeDMatrix {
    public static void main(String args[]) {
        int threeD[][][] = new int[3][4][5];

        // 遍历初始化数组
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                for (int k = 0; k < 5; k++) {
                    threeD[i][j][k] = i * j * k;
                }
            }
        }

        // 遍历输出数组
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                for (int k = 0; k < 5; k++) {
                    System.out.print(threeD[i][j][k] + " ");
                }
                System.out.println();
            }
            System.out.println();
        }
    }
}

程序运行结果如下：

0  0  0  0  0
0  0  0  0  0
0  0  0  0  0
0  0  0  0  0
 
0  0  0  0  0
0  1  2  3  4
0  2  4  6  8
0  3  6  9  12
 
0  0  0  0  0
0  2  4  6  8
0  4  8  12  16
0  6  12  18  24

另一种数组声明语法

声明数组还有第二种格式：
type[ ] var-name;

这里，方括号紧跟在类型标识符 type 的后面，而不是跟在数组变量名的后面。

例如，下面的两个定义是等价的：

int a1[] = new int[3];
int[] a2 = new int[3];

下面的两个定义也是等价的：

char twod1[][] = new char[3][4];
char[][] twod2 = new char[3][4];

包含这种数组声明格式主要是为了方便。

🧸这次的分享就到这里啦，继续加油哦^^
🍭有出错的地方欢迎在评论区指出来，共同进步，谢谢啦