Java数组详解

今天继续更新Java系列，下面看下Java的数组，会结合内存分析来讲解数组。

概述

为什么需要数组呢，比如，需要统计公司员工的工资情况，这个时候用变量的话就需要定义好多个变量，这样会很麻烦，因此数组就很适合这种场景。

数组是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，通过编号的方式对这些数据进行统一的管理。

数组的特点：

• 数组本身是引用数据类型，但数组中的元素可以是任何数据类型
• 创建数组对象会在内存中开辟一整块连续的空间，占据空间的大小取决于数组的长度和数组中元素的类型
• 数组中的元素在内存中是依次紧密排列的有序的
• 数组一旦初始化完成，其长度就是确定的，而数组的长度一旦确定就不能修改
• 可以直接通过下标的方式调用指定位置的元素
• 数组名中引用的是这块连续空间的首地址

一维数组

声明

格式：

//推荐
元素的数据类型[] 一维数组的名称;
//不推荐
元素的数据类型  一维数组名[];

举例：

int[] arr;
int arr1[];
String[] arr3;  //引用类型变量数组

数组的维度：在Java中数组的符号是[]，[]表示一维，[][]表示二维。

数组的元素类型：可以是任意的Java的数据类型。

数组名：数组名也是变量名，按照变量的命名规范来命名。

注：Java中声明数组时不能指定长度(数组中元素的个数)， 例如int a[5];是非法的。

初始化

静态初始化：
数组变量的初始化和数组元素的赋值操作同时进行称为静态初始化，本质是用静态数据为数组初始化，此时数组的长度由静态数据的个数决定。

格式1：

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,...};
或者
数据类型[] 数组名;
数组名 = new 数据类型[]{元素1,元素2,元素3,...}; //数组本身是引用数据类型，所以要用new创建数组实体

举例：

int[] arr = new int[]{1,2,3,4,5};
//或者
int[] arr;
arr = new int[]{1,2,3,4,5};

格式2：

数据类型[] 数组名 = {元素1,元素2,元素3...}; //必须在一个语句完成，不能分成两个语句

举例：

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

动态初始化：
数组变量的初始化和数组元素的赋值操作分开进行称为动态初始化。动态初始化中只确定了元素的个数，而元素值此时只是默认值，真正的数据需要后面单独一个个赋值。

格式：

数组存储的元素的数据类型[] 数组名字 = new 数组存储的元素的数据类型[长度];
或者
数组存储的数据类型[] 数组名字;
数组名字 = new 数组存储的数据类型[长度];

注：数组长度一旦指定不可更改。

举例：

int[] arr = new int[5];
//或者
int[] arr;
arr = new int[5];

使用

长度：每个数组都有一个属性length来指明它的长度，每个数组一旦初始化长度就是确定且不可变的。

引用：每个存储到数组的元素都会自动拥有一个从0开始的编号，这个编号称为数组索引或下标，可以通过数组的索引或下标访问数组中的元素。

遍历

将数组中每个元素分别获取出来就是遍历，for循环与数组的遍历是绝配。

举例：

public class ArrayTest {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5};
        //打印数组的长度，输出结果是5
        System.out.println("数组的长度：" + arr.length);
        //遍历输出数组中的元素
        System.out.println("数组的元素有：");
        for(int i=0; i<arr.length; i++){
            System.out.println(arr[i]);
        }
    }
}

默认值

数组是引用类型，当使用动态初始化方式创建数组时，元素值只是默认值。

对于基本数据类型，默认初始化值各有不同，对于引用数据类型，默认初始化值为null。

内存分析

Java虚拟机的内存划分

为了提高运算效率，对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

区域名称	作用
虚拟机栈	用于存储正在执行的每个Java方法的局部变量表等。局部变量表存放了编译期可知长度的各种基本数据类型、对象引用，方法执行完自动释放。
堆内存	存储对象(包括数组对象)，new创建的都存储在堆内存。
方法区	存储已被虚拟机加载的类信息、常量、(静态变量)、即时编译器编译后的代码等数据。
本地方法栈	当程序中调用了native的本地方法时，本地方法执行期间的内存区域
程序计数器	程序计数器是CPU中的寄存器，它包含每一个线程下一条要执行的指令的地址

一维数组在内存中的存储

一个一维数组内存图：

public static void main(String[] args) {
  	int[] arr = new int[3];
  	System.out.println(arr); //[I@5f150435
}

程序执行流程：

1. main方法进入方法栈执行。
2. 创建数组，JVM会在堆内存中开辟空间，存储数组。
3. 数组在内存中会有自己的内存地址，以十六进制数表示。
4. 数组中有3个元素，默认值为0。
5. JVM将数组的内存首地址赋值给引用类型变量arr。
6. 变量arr保存的是数组内存中的地址，而不是一个具体数值，因此称为引用数据类型。

数组下标为什么从0开始：因为第一个元素距离数组首地址间隔0个单元格。

两个一维数组内存图：

public static void main(String[] args) {
    int[] arr = new int[3];
    int[] arr2 = new int[2];
    System.out.println(arr);
    System.out.println(arr2); //两个数组独立
}

两个变量指向一个一维数组：

public static void main(String[] args) {
    //定义数组，存储3个元素
    int[] arr = new int[3];
    //数组索引进行赋值
    arr[0] = 5;
    arr[1] = 6;
    arr[2] = 7;
    //输出3个索引上的元素值
    System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);
    //定义数组变量arr2，将arr的地址赋值给arr2
    int[] arr2 = arr;
    arr2[1] = 9;
    System.out.println(arr[1]);
}

两个数组变量本质上代表同一个数组。

多维数组

概述

Java语言提供了支持多维数组的语法，如果把以为数组当成几何中的线性图形，那么二维数组就相当于一个表格。

对于二维数组的理解，可以看成是一维数组又作为另一个一维数组的元素存在。

其实从数组底层的运行机制来看，没有多维数组。

声明和初始化

声明：

//推荐
元素的数据类型[][] 二维数组的名称;
//不推荐
元素的数据类型  二维数组名[][];
//不推荐
元素的数据类型[]  二维数组名[];

举例：

public class Test20TwoDimensionalArrayDefine {
    public static void main(String[] args) {
        //存储多组成绩
        int[][] grades;
        //存储多组姓名
        String[][] names;
    }
}

注：对于int[] x, y[];，其中x是一维数组，y是二维数组。

静态初始化：
格式：

int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

对于二维数组的长度，比如上面第三个一维数组的长度可以用arr[2].length来表示。
举例：

int[][] arr = {{1,2,3},{4,5,6},{7,8,9,10}}; //声明与初始化必须在一句完成
int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9,10}};
int[][] arr;
arr = new int[][]{{1,2,3},{4,5,6},{7,8,9,10}};

动态初始化：
格式1：规则二维表，每一行的列数都是相同的。

//确定行数和列数
元素的数据类型[][] 二维数组名 = new 元素的数据类型[m][n];
//其中m:表示这个二维数组有多少个一维数组，或者说一共二维表有几行
//其中n:表示每一个一维数组的元素有多少个，或者说每一行共有一个单元格
//此时创建完数组，行数、列数确定，而且元素也都有默认值
//再为元素赋新值
二维数组名[行下标][列下标] = 值;

格式2：不规则二维表，每一行的列数不一样。

//先确定总行数
元素的数据类型[][] 二维数组名 = new 元素的数据类型[总行数][];
//此时只是确定了总行数，每一行里面现在是null
//再确定每一行的列数，创建每一行的一维数组
二维数组名[行下标] = new 元素的数据类型[该行的总列数];
//此时已经new完的行的元素就有默认值了，没有new的行还是null
//再为元素赋值
二维数组名[行下标][列下标] = 值;

长度和角标

• 二维数组的长度或行数可表示为二维数组名.length
• 二维数组的某一行可表示为二维数组名[行下标]，此时相当于获取其中一组数据，它本质上是一个一维数组
• 某一行的列数可表示为二维数组名[行下标].length，因为二维数组的每一行是一个一维数组
• 某一个元素可表示为二维数组名[行下标][列下标]，即先确定行/组，再确定列

二维数组的遍历

格式：

for(int i=0; i<二维数组名.length; i++){ //二维数组对象.length
    for(int j=0; j<二维数组名[i].length; j++){ //二维数组行对象.length
        System.out.print(二维数组名[i][j]);
    }
    System.out.println();
}

举例：

public class Test23TwoDimensionalArrayIterate {
    public static void main(String[] args) {
        //存储3个小组的学员的成绩，分开存储，使用二维数组。
        int[][] scores = {
                {85,96,85,75},
                {99,96,74,72,75},
                {52,42,56,75}
        };
        System.out.println("一共有" + scores.length +"组成绩.");
        for (int i = 0; i < scores.length; i++) {
            System.out.print("第" + (i+1) +"组有" + scores[i].length + "个学员，成绩如下：");
            for (int j = 0; j < scores[i].length; j++) {
                System.out.print(scores[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

内存解析

二维数组本质上是元素类型是一维数组的一维数组。

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

//声明二维数组，并确定行数和列数
int[][] arr = new int[4][5];
//确定元素的值
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr.length; j++) {
        arr[i][j] = i + 1;
    }
}

//声明一个二维数组，并且确定行数
//因为每一行的列数不同，这里无法直接确定列数
int[][]  arr = new int[5][];
//确定每一行的列数
for(int i=0; i<arr.length; i++){
    arr[i] = new int[i+1];
}
//确定元素的值
for(int i=0; i<arr.length; i++){
    for(int j=0; j<arr[i].length; j++){
        arr[i][j] = i+1;
    }
}

最后，今天的内容就到这里，Java教程持续更新中，喜欢的话点个关注吧，下篇见！