「JAVA」数组、多维数组，动态、静态初始化，数组JVM内存模型分析

什么是数组

什么是数组

所谓数组，是具有相同数据类型的若干变量或者数据按照一定排序规则组合起来的一种数据存储格式。数组中的数据称为数组元素，我们使用索引来标识数组元素在数组中的存储位置，索引从0开始，步长是1，其后的索引依次递增：

数组

其中，数据类型包括以下两种：

• 基本数据类：byte,short,int,long,float,double,char,boolean
• 引用数据类型：类,接口,数组，基本数据类型的包装类也数据引用数据类型

Java中数组的定义

数组的定义（声明）：

• 方式1：数据类型[] 数组名; 如：int[] ages; 推荐使用此方式创建数组。
• 方式2：数组元素的类型 数组名[]; int ages[]; 此方法不推荐

数组的初始化：

数组必须先初始化，才能使用，也就是要先为数组和数组元素在JVM内存模型中分配空间，给每个数组元素赋初始值，初始值可以在创建数组时指定，也可以只指定数组长度，然后使用对应数据类型的默认值作为其初始值，下图是各个数据类型的默认值：

数据类型默认值

null 表示没有指向任何存储空间，是空值；如果将null赋予对象，则表示该对象引用为空，将会被GC回收，使用此对象调用方法，或者操作数据会触发NullPointerException(空指针异常)。

初始化数组有两种方式：静态初始化 和 动态初始化；但是无论以哪种方式初始化数组，一旦初始化完成，数组的长度就固定了，数组中的元素个数也就已经固定了，不能改变，所以说数组是固定长度的。

数组的静态初始化： 由我们（程序员们）来为每一个数组元素设置初始化值，也就是说知道要在数组中存储哪些数据；此时数组的长度JVM根据设置的初始值来分配，不需要再设置，语法如下所示：

// 方式一：
元素数据类型[] 数组名 = new 元素数据类型[]{初始值1, 初始值2, 初始值3,.......};
int[] nums = new int[]{13, 14, 520};

// 方式二：
元素数据类型[] 数组名 = {初始值1, 初始值2, 初始值3,.......};
int[] nums = {13, 14, 520};

Java中创建数组时，在JVM中建立对应的内存模型，在栈中保存数组变量及其内存地址，而数组中的内容则保存在堆中，详情如下所示：

数组静态初始化的JVM模型

数组的动态初始化: 由我们（程序员们）来设置数组长度)，而数组中元素的初始值由JVM赋予；语法如下：

// 数组静态初始化语法：
元素数据类型[] 数组名 = new 元素数据类型[ length ];
int[] nums= new int[100];

// 但是， 不能同时使用静态初始化和动态初始化，比如：
int[] nums = new int[3]{13, 14, 520}; // 这种写法是错误的。

那么什么时候使用静态初始化，什么时候使用动态初始化呢？

• 如果提前知道需要存储的数据,优先选用静态初始化，否则使用动态初始化来创建数组；
• 知道数组长度时，优先使用动态初始化；
• 数组长度和需要存储的数据都知道时，两种方式都可以，任选其一即可；

数组动态初始化的JVM模型

数组的基本操作：

1.数组基本操作：

• 获取元素：元素类型 变量 = 数组名[index]；
• 设置元素：数组名[index] = 值；
• 数组长度：int len = 数组名.length; 注意这里的length是属性，不是方法，从调用上方式上也能看出来；
• 索引范围：从0开始，逐一递增. 直至 length-1：[0，length-1]；
• 最大值：getMax()；
• 最小值：getMin()；

2.操作数组常见异常：

• NullPointerException：空指针异常，数组或者变量未初始化就直接操作时会触发；
• ArrayIndexOutOfBoundsException：数组的索引越界异常，获取数组元素时使用的索引超出了数组的索引范围时会触发。

3.获取元素在数组中的位置索引：

• 元素在数组中第一次出现的位置的索引：indexOf()
• 元素在数组中最后一次出现的位置的索引：lastIndexOf()

数组在main函数中的应用：

main 函数的中数组

可以接收传入的参数，一般是提供给用户传入参数来完成一些特定的操作的。

多维数组

多维数组：以数组为数据类型创建数组，也就是数组中的数组，比如：二维数组可以这样来初始化：

二维数组的静态初始化：

// 二维数组的静态初始化
int[][] arr = new int[][] {{1,2,3} ,{4,5},{6}};

二位数组的动态初始化：

// 创建一个长度为3的二维数组,每一个元素(一维数组)的长度为5.
int[][] arr = new int[3][5] ; 

多维数组的取值：

// 多维数组的取值：
int[1][1]; // 表示第2个一维数组的第2个元素；

创建多维数组时，JVM也会为其创建内存模型，虽然在JVM 中是这样的：

多维数组的JVM模型

• 一维数组：数组中的每一个元素都是一个值(基本类型或者引用类型)。
• 二维数组：数组中的每一个元素是一个一维数组。
• 三维数组：数组中的每一个元素是一个二维数组。

依次类推。

杨辉三角

杨辉三角就是一个典型的多维数组实例：它的规律是每行起始和结束两个数都是1，每个数都等于它的上方两个数之和，详情如下图所示：

杨辉三角

杨辉三角是二项式系数在三角形中的一种几何排列，最早出现于北宋贾宪的《黄帝九章算经细草》，后被南宋数学家杨辉抄录于《详解九章算法》一书。

在Java中可以使用多维数组打印杨辉三角，代码如下：

public static void main(String []args) {

           	 // 杨辉三角的行数
             int num = 10;

             for (int i = 0; i < num; i++) {
                 int number = 1;
                 // 创建一维数组保存每行的数
                 System.out.format("%" + (num - i) * 2 + "s", "");
                 for (int j = 0; j <= i; j++) {
                         System.out.format("%4d", number);
                         number = number * (i - j) / (j + 1);
                 }
            	 System.out.println();
              }
    	}

foreach

我们在使用循环迭代数组的时候，有时候并不关心迭代元素的索引，迭代数组元素的时候，直接操作数组元素，不关心操作数组的索引。所以，从Java5开始(JDK1.5)开始，Java提供了一种新的语法，foreach（增强for循环）语法如下:

// 增强for循环 语法
for(元素数据类型 变量 : 数组名){
    循环体
}

通过foreach，我们便可以快速迭代出数组中的元素：

public static void main(String[] args) {

    for (String arg : args )
    {
         System.out.print(arg);
         System.out.print(" ");
    }}

接下来，通过反编译字节码文件，看看JVM是如何实现foreach的：

public static void main(String args[]) {
    String args1[] = {
     "-d", "-classpath", "-v"
    };
    String args2[] = args1;
    int i = args2.length;
    for (int j = 0; j < i; j++)
    {
        String s = args2[j];
        System.out.println(s);
     }}

不难发现，foreach其实在底层依然是使用for循环+索引来操作数组的，虽然把foreach称为增强for循环，但其底层依然是使用for循环实现的，我们将其称之为语法糖，目的就是为了吸引开发者，让开发者写更少的代码，这恰恰也是开发者们乐意愿意看到的。

foreach虽然会少些很多代码，但论性能，灵活性却不如for循环，所以如果只关心元素而不关心索引，首选foreach，其他情况下还是应该for循环；在集合中也是这样的道理。

方法的可变参数

Java5还有另一个新特性：方法的可变参数，这里可变说的是参数的个数可变，并不是参数值可变，看如下的代码中，方法getArgsLength便使用了可变参数：

public static void main(String[] args) {
    System.out.println(getArgsLength("-d", "-classpath"));}
// 获取参数长度private static int getArgsLength(String... args) {    return args.length;}

还是将其反编译，查看JVM对可变参数的实现；不难发现，方法的可变参数其实也是一个语法糖，因为其底层还是一个数组，因此，可以把可变参数类型当做一个数组来处理，比如元素输出：

public static void main(String args[]){
    System.out.println(getArgsLength(new String[] {
      "-d", "-classpath"
    }));}
private static transient int getArgsLength(String as[]){     return as.length;}

需要注意的是：

1. 可变参数必须作为方法的最后一个参数，避免与其他参数产生歧义，引发异常；
2. 方法最多只能有一个可变参数。

完结。老夫虽不正经，但老夫一身的才华