【Java】数组

花儿虽然是静悄悄的开​​​​​​​ 

但也鲜艳无比

---

目录

1.数组基本概念

1.1 为什么需要数组 

1.2 什么是数组 

1.3 数组的创建及初始化 

1.4 数组的使用 

2. 数组是引用类型

2.1 认识JVM的内存分布

2.2 基本类型变量与引用类型变量的区别

2.3 认识null

2.4 参数传数组类型

3.二维数组 

---

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

2.2 基本类型变量与引用类型变量的区别

基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值

引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int[] arr = new int[]{1,2,3};
    }
}

a 是基本数据类型，它直接在栈上开辟空间，然后把值存储在对应的空间里面 

arr 是数组类型的引用变量，其内部保存的内容可以简单理解成是数组在堆空间中的首地址

引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该地址，引用变量便可以去操作对象

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int[] arr = new int[]{1,2,3};
        arr[0] = 99;
    }
}

通过 arr 在栈中存储的地址，然后找到堆中对应地址的空间，去访问 arr[0]，将其值改为 99 

2.3 认识null

null 在 Java 中表示 "空引用" , 也就是一个不指向对象的引用

null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操 作. 一旦尝试读写, 就会抛出 NullPointerException.

注意: Java 中并没有约定 null 和 0 号地址的内存有任何关联 

2.4 参数传数组类型

我们之前说方法返回值最多只能有一个，如果想改变形参的同时也改变实参，那我们就可以把数组作为实参传给形参

那为什么把数组作为实参传给形参就可以改变实参咧？ 

因为我们开辟了一个数组，它一定是开辟在堆上的，栈上存的是堆上数组的首地址，把栈上存的地址传给了形参，那么形参此时里面存储的也是这个地址，当形参去读取的时候也找到了堆上这块空间了，所以它就会直接去操作这块空间。形参指向的是这块空间，实参也指向了这块空间，那形参改变了这块空间的内容，实参还是指向了这块空间的，所以当实参是数组传给形参的时候改变形参就会改变实参 

public class Test {
    public static void fun1(int[] arr) {
        arr[0] = 99;
    }
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3};
        System.out.println(arr[0]);
        fun1(arr);
        System.out.println(arr[0]);
    }
}

 打印结果：

当大家看到上面这幅图片分析，应该也就理解了为什么实参是数组时传给形参会改变实参了。  

public class Test {
    public static void fun1(int[] arr) {
        arr = new int[7];
        arr[0] = 99;
    }
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3};
        System.out.println(arr[0]);
        fun1(arr);
        System.out.println(arr[0]);
    }
}

打印结果： 

当实参数组时，将实参栈中存的地址传给了形参，但是在形参中有重新开辟了一块空间，那么形参将会指向新的空间，当它改变新的空间的值时，将不会影响到实参，也不会改变实参数组里面的值。

注：数组不需要销毁，当没有数组变量指向它的时候就会自动销毁 

总结: 所谓的 "引用" 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大) 

注：

• 传给形参基本数据类型的变量，相当于临时拷贝
• 传给形参引用数据类型的变量，相当于把变量在栈上存储的堆中数组的地址传给了形参，那么实参和形参同时指向同一块空间

2.5 作为函数的返回值

求斐波那契数列的前N项：

public class Test {
    public static int[] fib(int n){
        if(n <= 0){
            return null;
        }
        int[] array = new int[n];
        array[0] = array[1] = 1;
        for(int i = 2; i < n; ++i){
            array[i] = array[i-1] + array[i-2];
        }
        return array;
    }
    public static void main(String[] args) {
        int[] array = fib(10);
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

方法中返回数组相当于返回了数组的地址。 

3.二维数组 

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组

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

看到这幅图相信就明白了二维数组了

二维数组的遍历: 

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

打印结果：