3.6 数组理解

一、内存中的数组

　　数组引用变量只是一个引用，这个引用变量可以指向任何有效的内存，只有当该引用指向有效内存后，才可以通过该数组变量来访问数组元素。

实际的数组对象被存储在堆(heap)内存中；如果引用该数组对象的数组引用变量是一个局部变量，那么它被存储在栈（stack）内存中。数组在内存中的存储示意图：

　　如果需要访问如图所示的堆内存中的数组元素，则程序只能通过p[index]的形式实现。即数组引用变量是访问堆内存中数组元素的根本方式。

堆内存和栈内存：

堆（heap）内存：Java虚拟机启动时分配一块永久的、很大的内存区。堆内存只有一块。

栈（stack）内存：每个方法运行时分配一块临时的、很小的内存区。每个方法都有自己的栈区，当方法结束时，对于的栈区就会被销毁。

　　当一个方法执行时，每个方法都会建立自己的内存栈，在这个方法内定义的变量将会逐个放到这个栈内存中，随着方法的执行结束，这个方法的内存栈也将随之销毁。因此，所有在方法中定义的局部变量都是在栈内存中的；在程序创建一个对象时，这个对象将被保存在运行时的数据区中，以便重复利用（因为对象的创建成本比较大），这个运行时数据区就是堆内存。堆内存的对象不会随着方法的结束而消失，即使方法结束后，这个对象还可以被其他另外一个引用变量所引用（在方法的参数传递中很常见），则这个对象依然不会被销毁。只有当一个对象没有任何变量引用它时，系统的垃圾回收器才会在合适的时候回收它。

 　　如果堆内存中的数组不在有任何引用变量指向自己，则这个数组将会成为垃圾，该数组所占的内存也会被系统的垃圾回收器回收。因此为了让垃圾回收器回收一个数组所占的内存空间，可以将该数组便便赋值为null，也就切断数组引用变量和实际数组之间的引用关系，实际的数组也就成为垃圾。

　　只要类型相互兼容，就可以让一个数组变量指向另一个实际的数组，这样会让人产生数组长度可变的错觉。 

class ArrayTest 
{
    public static void main(String[] args) 
    {
        //静态方法定义数组
        int[] a={1,3,5};
        //动态初始化定义数组
        var b=new int[4];
        
        System.out.println("数组b的长度为："+b.length);
        //循环输出数组a,b
        for(int i:a)
        {
            System.out.print("  "+i);
        }
        System.out.print("
");
        for(int i=0;i<b.length;i++)
        {
            System.out.print("  "+b[i]);
            if(i==b.length-1)
                System.out.print("
");
        }
        //因为a、b都是int[]引用类型，所以可以让b指向a引用指向的数组
        b=a;
        System.out.println("指向a指向的数组后引用变量b指向的数组长度："+b.length);
    }
}
---------- 运行java（捕获窗口） ----------
数组b的长度为：4
  1  3  5
  0  0  0  0
指向a指向的数组后引用变量b指向的数组长度：3

输出完成 (耗时 0 秒) - 正常终止

 在变量与b变量都引用了第一个数组后，此时在堆内存的原数组元素失去了引用，变成了垃圾，等待垃圾回收器来回收它。

二、基本类型的数组的初始化

　　对于基本类型的数组而言，数组元素的值直接存储在对应的数组元素中，因此，初始化数组时，先为该数组分配内存空间，然后直接将数组元素的值存入对应数组元素中。

class PrimitiveArrayTest 
{
    public static void main(String[] args) 
    {
        //定义一个int[]类型的数组变量
        int[] array;
        //动态初始化数组，数组长度为5
        array=new int[5];
        //采用循环方式为数组每个元素赋值
        for(var i=0;i<array.length;i++)
        {
            array[i]=i+10;
        }
        //循环输出数组
        for(int i:array)
        {
            System.out.println(i);
        }
    }
}
---------- 运行java（捕获窗口） ----------
10
11
12
13
14

输出完成 (耗时 1 秒) - 正常终止

 执行int[] array，此时分配一个栈内存和一个堆内存（java虚拟机启动的时候就有），定义了一个空引用，这个引用变量并未指向任何有效的内存，也就无法知道数组的长度

 array=new int[5],动态初始化后，系统将为该数组分配内存存储空间，并分配默认初始化值：所有数组元素赋值为0。

        for(var i=0;i<array.length;i++)
        {
            array[i]=i+10;
        }
循环为数组赋值

三、引用类型的初始化

基本类型的赋值：直接将该值存入变量的内存中。

引用类型的赋值：将该引用对象的第一个内存单元的编号（首地址）存入变量。

引用类型数组的数组元素时引用，因此情况更加复杂。每个数组元素里存储的还是引用，它指向另一块内存，这块内存里存储了有效数据。

定义一个Person类

class Person 
{
    public int age;
    public double height;
    //定义一个方法
    public void info()
    {
        System.out.println("年龄："+age+",身高："+height);
    }
}

 下面程序定义一个Person[]数组，接着初始化这个Person[]数组，并为这个数组的每个元素指定值。

public class ReferenceArrayTest
{
    public static void mian(Srting[] args)
    {
        //定义一个sudentd数组，类型Person[]
        Person[] students;
        //执行初始化
        students=new Person[2];

        //创建两个Person实例
        var zhang=new Person();
        zhang.age=15;
        zhang.height=158;

        var lee=new Person();
        lee.age=16;
        lee.height=168;

        students[0]=zhang;
        students[1]=lee;

        //下面代码的执行结果完全一样
        lee.info();
        students[0].info();
    }
}

 执行Person[] students;代码时，这行代码仅仅在栈内存中定义了一个引用变量，也就是一个指针，这个指针并未指向任何有效内存区。

执行动态初始化，默认由系统指定初始值null。

 students=new Person[2];

 然后代码定义了zhang和lee两个Person实例，实际上分配了四个内存，在栈内存储zhang和lee两个引用变量，还在堆内存储两个Person实例，如下所示：

  students[0]=zhang;
  students[1]=lee;

　　从图可以看出zhang和students[0]同时指向一个内存区，且都为引用变量，因此通过zhang和students[0]来访问Person实例的方法和变量效果是一样的，无论修改students[0]指向的实例还是zhang指向的实例，所修改的其实是一个内存区。

四、没有多维数组

　　java语言的数组类型还是引用类型，这个引用指向真实的数组内存。数组元素的类型也可以是引用，如果数组元素的引用再次指向真实的数组内存，这种情况看上去就很像多维数组。

　　定义一个变量的用法：type varName,type是变量类型。如果定义一个引用变量的数组类型，只需要将这个type具体成int[]。

　　二维数组的定义：

type[][] arrayName;

 从采用上面的语法格式来定义二维数组，但它的实质还是一维数组，只是数组元素还是引用，数组元素里保存的引用指向一位数组。

对二维数组的初始化，同样可以将数组看成以为数组初始化，把这个“二维数组”当成一一维数组，其元素类型是type[]类型，可以采用以下语法进行初始化

arrayName=new type[length][]

 上面的语法相当于初始化一个一维数组，这个一维数组的长度为length，同样这个一维数组的数组元素是引用类型（数组类型），所以系统为每个元素分配的初始值为null。这个二维数组完全可以当成一维数组：使用new type[length]相当于定义了length个type类型变量；类似的，使用new type[length][]初始化这个数组后，相当于定义了length个type[]类型的变量，当然这个type[]类型的变量都是数组类型，因此需要再一次进行初始化。

class 二维数组
{
    public static void main(String[] args)
    {
        //定义一个二维数组
        int[][] a;
        //把a当成一维数组进行初始化，初始化a为一个长度为4的数组
        //a数组的数组元素有是引用类型
        a=new int[4][];
        //把a当成一维数组，遍历a数组的每个元素
        for(int i=0;i<a.length;i++)
        {
            System.out.println(a[i]);
        }
        //初始化a数组的第一个元素
        a[0]=new int[2];
        a[0][0]=1;
        a[0][1]=2;

        //遍历二维数组a的第一个元素
        for(int i=0;i<a[0].length;i++)
        {
            System.out.println(a[0][i]);
        }
    }
}

 [][] a;这一行代码，将在栈里定义一个引用变量，这个变量并未指向任何有效的内存空间，此时堆内存还未为这行代码分配任何存储区。

a=new int[4][];程序对数组进行初始化，这行代码让a变量指向一块长度为4的内存空间，这个长度为4的数组里每个数组元素都是引用类型（数组类型），系统为这些数组元素分配初始值：null。此时数组a在内存中存储的示意图：

 a[0]=new int[2];
 a[0][0]=1;
 a[0][1]=2;

对一个数组原素a[0]进行初始化

 初始化多维数组时，可以只指定左边维的大小；当然也可以一次指定每一维的大小。

int[][] b=new int[3[4];

 上面的代码定义一个b数组变量，这个变量指向一个长度为3的数组，这个数组的每个元素又是一个数组类型，他们各自指向长度为4的int[]数组，每个数组的元素为0。示意图为：

 还可以使用静态初始化方式来初始化二维数组，使用静态初始化方式来初始化二维数组，二维数组的每个数组元素都是一维数组，因此必须指定多个一维数组作为二维数组的初始值。代码如下：

//使用静态初始化方法来初始化一个二维数组
String[][] str1=new String[][]{new String[3],new String[]{"hello"}}

 结论：二维数组是一维数组，其数组元素是一维数组；三维数组其数组元素是二维数组。