【Java】数组1

1.数组基本概念

1.1 为什么需要数组

假设成绩是 int 类型的，我们现在需要存一个人的一个成绩，我们直接可以用一个整型变量就可以存放 一个人的成绩。

int student = 97;

那么大家在设想一下，我们需要存放一个班的每一位学生的成绩，要是一个班有 100 个学生，难不成我们要创建 100 个整型变量来存储嘛？要是一个班有 1000 个学生，难道我们要创建 1000 个整型变量去存储嘛？

要是我们需要存储一个学生的多门成绩又该怎样存储？

要是我们需要储存多个学生的多门成绩又该怎样存储？

那接下来我们就一起系统的学习数组的知识，你就知道如何去解决上述的问题了。

1.2 什么是数组

数组：可以看做是一组相同类型元素的集合，在内存中是按一段连续的空间进行存储的

数组中存放的元素其类型相同

数组的空间是连在一起的

举例说明：假设我们需要存储十个人的成绩，我们知道成绩的类型都是一样的，那么我们就可以采用数组去存这一组成绩

1.3 数组的创建及初始化

1.数组的创建

T：表示数组中存放元素的类型

T[]：表示数组的类型

N：表示数组的长度

int[] num = new int[7];

上述代码的含义：创建了一个 int 类型的数组，可以容纳 7 个 int 类型的元素。

数组的类型也就代表了里面存储元素的类型

数组的类型可以是 int  double...

2.数组的初始化

数组的初始化可以分为 动态初始化 和 静态初始化

①动态初始化

动态初始化：在创建数组的时候，直接给它指定元素的个数，不给它初始化 就叫做动态初始化

int[] num = new int[7];

这个代码就是动态初始化，在创建的时候直接给了元素个数并没有给它赋初值

其实动态初始化默认将指定大小空间的元素个数初始化为了默认值

动态初始化里面的元素默认初始化为默认值的证明：  

public class Test {
    public static void main(String[] args) {
        int[] array = new int[7];
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

打印结果：

我们将动态初始化的 int 类型的数组，用 for 循环遍历打印一遍就可以发现里面的内容被初始化为 int 类型的默认值了，int 类型的默认值就是 0

array.length：就是用来获取 array 这个数组的元素个数

补充说明不同类型的默认值：

byte ---》0        short---》0         int---》0     
long ---》0         float---》0.0f     double---》0.0       
char ---》/u0000                         boolean---》false

如果数组中存储元素类型为引用类型，默认值为null

动态初始化记忆口诀：指定元素的个数，用默认值来初始化

②静态初始化

静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定

int[] array1 = new int[]{1,2,3,4,5,6,7};
int[] array2 = {1,2,3,4,5,6};

这两句代码就是静态初始化，它们是根据初始化数据元素的个数来指定数组的长度

静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度

静态初始化时, {} 中数据类型必须与 [] 前数据类型一致

静态初始化可以简写，省去后面的new T[]，但是编译器编译代码时还是会还原

静态初始化是根据{}中元素个数来确定数组的长度的证明：

public class Test {
    public static void main(String[] args) {
        int[] array1 = new int[]{1,2,3,4,5,6,7};
        int[] array2 = {1,2,3,4,5,6};
        System.out.println(array1.length);
        System.out.println(array2.length);
    }
}

打印结果：

通过打印结果我们就能够证明，静态初始化的确是根据 {} 中元素的个数来确定数组的长度。  

静态初始化口诀：根据元素个数，确定数组长度

动态和静态初始化也可以分为两步：

int[] array1;
array1 = new int[7];
int[] array2;
array2 = new int[]{1,2,3,4,5,6};

但是省略格式不可以：

分两步，省去后面的 new T[ ] 就会直接报错

1.4 数组的使用

1.如何访问数组中的元素

上面我们已经说过数组在内存中是按一段连续的空间进行存储的，数组的下标是从 0 一直递增的

首元素的下标是0，下一个下标就是 1 ，然后依次递增

那么数组在内存中是按一段连续的空间进行存储的，跟数组的下标有什么关系了？？？

因为数组在内存中是按一段连续的空间进行存储的，所以当数组的下标进行改变时编译器就知道了数组从起始位置应该跳过多少个字节大小的空间去访问当前下标的元素。

假设有这样一个数组：

int[] array = new int[]{1,2,3,4,5,6};

当我们要访问 array[1] 时，因为 array 是 int 类型的数组，所以当下标为 1 时那么将从数组首地址跳过一个 int 大小的空间来到 array[1] 元素的起始位置。

结论： 数组在内存中是按一段连续的空间进行存储的，当数组类型不同进行访问下标的元素跳过的空间大小也是不同的。如果当数组内存空间不连续，将无法访问指定下标的元素。

数组是一段连续的内存空间，因此支持随机访问，即通过下标访问快速访问数组中任意位置的元素

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

这样就可以通过不同的下标去访问数组中指定的元素了

下标从0开始，介于[0, N）之间不包含N，N为元素个数，不能越界，否则会报出下标越界异常

2.遍历数组

"遍历" 是指将数组中的所有元素都访问一遍, 访问可以对数组中的元素进行某种操作（比如：打印）

如果我们要打印一个整型数组，这个数组中假设有 100 个元素，要是我们一个一个打印，那么就会麻烦，所以我们通常会采用遍历来打印整个数组中的元素

那我们通常采用 for 循环来遍历数组，通过 for 循环有两种方式来遍历

①方式一：在 for 循环中通过数组对象.length 来获取数组的长度来遍历整个数组

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

②方式二：使用 for-each 遍历数组

public class Test {
    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5,6,7};
        for (int x: array) {
            System.out.println(x);
        }
    }
}

for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错.

for-each执行方式：每次遍历 array 数组时把遍历的值给 x，然后通过 x 打印，注意 x 既然是存储array 数组里面元素的，那么就应该跟数组元素类型一样

注：还有可以通过 toString 将数组转换成字符串来打印，但是它不能进行遍历（目前只需要了解）

2. 数组是引用类型

2.1 认识JVM的内存分布

内存是一段连续的存储空间，主要用来存储程序运行时数据的，当程序运行时代码需要加载到内存 ， 程序运行产生的中间数据要存放在内存 ， 程序中的常量也要保存 ，有些数据可能需要长时间存储，而有些数据当方法运行结束后就要被销毁。

如果内存没有内存分布的话就会变得很乱，就像没有整理的房间一样，当房间经过整理把生活用品放进洗澡间，把衣服放进衣柜...，那么放进就会很整洁。内存分布也是同样的道理。

JVM对所使用的内存按照功能的不同进行了划分：

程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址

虚拟机栈(JVM Stack): 与方法调用相关的一些信息，每个方法在执行时，都会先创建一个栈帧，栈帧中包含有：局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息，保存的都是与方法执行时相关的一些信息。比如：局部变量。当方法运行结束后，栈帧就被销毁了，即栈帧中保存的数据也被销毁了。

本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的

堆(Heap): JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如 new int[]{1, 2, 3} )，堆是随着程序开始运行时而创建，随着程序的退出而销毁，堆中的数据只要还有在使用，就不会被销毁。

方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这个区域