java数组的理解-超级明白

java数组的理解

在我的理解中数组在程序中就是一个容器，像我们生活中的容器一样。
程序中的容器：是将多个数据存储到一起，每个数据称为该容器的元素。
先看看java中数组的概念是什么然后我们结合案例一起了解。
数组概念：数组就是用于存储数据的长度固定的容器，保证多个数据的数据类型要一致。

百度百科中对数组的定义：
所谓数组(array)，就是相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名，以便统一管理他们，然后用编号区分他们，这个名字称为数组名，编号称为下标或索引(index)。组成数组的各个变量称为数组的元素(element)。数组中元素的个数称为数组的长度(length)。

数组特点

数组的特点：

1、数组的长度一旦确定就不能修改

2、创建数组时会在内存中开辟一整块连续的空间。

3、存取元素的速度快，因为可以通过[下标]，直接定位到任意一个元素。

数组的分类

数组按维度分为分为一维数组和多维数组。

数组按照按照元素类型分：

• 基本数据类型的元素：存储数据值
• 引用数据类型的元素：存储对象（本质上存储对象的首地址）
  注意：无论数组的元素是基本数据类型还是引用数据类型，数组本身都是引用数据类型。
  理论不多说了，看着也是枯燥的。我们来看看一维数组是怎么使用的以及定义声明的。

一维数组的声明

• 一维数组的声明/定义格式

//推荐
数组类型[] 数组的名称;

//不推荐
数组类型 数组名[];

• 数组的声明，就是要确定：

（1）数组的维度：在Java中数组的标点符号是[]，[]表示一维，[][]表示二维

（2）数组的元素类型：即创建的数组容器可以存储什么数据类型的数据。元素的类型可以是任意的Java的数据类型。例如：int, String, Student等

（3）数组名：就是代表某个数组的标识符，数组名其实也是变量名，按照变量的命名规范来命名。数组名是个引用数据类型的变量，因为它代表一组数据。

不多哔哔直接上代码了

public class Test01ArrayDeclare {
    public static void main(String[] args) {
        //比如，要存储一个小组的成绩
        int[] scores;//声明了一个叫scores的int型的数组
        int grades[];
//        System.out.println(scores);//未初始化不能使用

        //比如，要存储一组字母
        char[] letters;

        //比如，要存储一组姓名
        String[] names;

        //比如，要存储一组价格
        double[] prices;

    }
}

注意：数组声明但是没有进行初始化是不能使用的哦。
下面我们继续看数组的初始化又是怎么操作的。
一维数组初始化又分为动态初始化和静态初始化。

一维数组的动态初始化

• 什么是动态初始化？
  动态初始化就是先确定元素的个数（即数组的长度），而元素此时只是默认值，并不是真正的数据。元素真正的数据需要后续单独一个一个赋值。
  动态初始化格式

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

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

注意：数组有定长特性，长度一旦指定，不可更改
例如，定义可以存储5个整数的数组容器，代码如下：

int[] arr = new int[5];

int[] arr;
arr = new int[5];

//错误的，后面有{}指定元素列表，就不需要在[]中指定元素个数了。
int[] arr = new int[5]{1,2,3,4,5};

一维数组的动态初始化演示

public class Test06ArrayInitialize {
    public static void main(String[] args) {
        int[] arr = new int[5];

        System.out.println("arr数组的长度：" + arr.length);
        System.out.print("存储数据到arr数组之前：[");
        for (int i = 0; i < arr.length; i++) {
            if(i==0){
                System.out.print(arr[i]);
            }else{
                System.out.print("," + arr[i]);
            }
        }
        System.out.println("]");

        //初始化
 /*       arr[0] = 2;
        arr[1] = 4;
        arr[2] = 6;
        arr[3] = 8;
        arr[4] = 10;*/

        for (int i = 0; i < arr.length; i++) {
            arr[i] = (i+1) * 2;
        }

        System.out.print("存储数据到arr数组之后：[");
        for (int i = 0; i < arr.length; i++) {
            if(i==0){
                System.out.print(arr[i]);
            }else{
                System.out.print("," + arr[i]);
            }
        }
        System.out.println("]");
    }
}

数组动态初始化元素默认值

总体来说一维数组的动态初始化就是就是把数组new出来给一个固定的数组长度然后给数组的元素赋值。
有动态初始化就有静态的初始化，我们来了解一下吧。

• 什么是静态初始化？
• 静态初始化就是用静态数据（编译时已知）为数组初始化。此时数组的长度由静态数据的个数决定。
• 格式

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

例如，定义存储1，2，3，4，5整数的数组容器

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

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

不会以为完了吧，嘿嘿还有哦

• 一维数组静态初始化格式2：

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
或
数据类型[] 数组名;
数组名 = new 数据类型[]{元素1,元素2,元素3...};

例如，定义存储1，2，3，4，5整数的数组容器。

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

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

一维数组静态初始化代码示例

public class Test02ArrayInitialize {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};//右边不需要写new int[]

        int[] nums;
        nums = new int[]{10,20,30,40}; //声明和初始化在两个语句完成，就不能使用new int[]

        char[] word = {'h','e','l','l','o'};

        String[] names = {"张三","李四","王五"};

        System.out.println("arr数组：" + arr);//arr数组：[I@1b6d3586
        System.out.println("nums数组：" + nums);//nums数组：[I@4554617c
        System.out.println("word数组：" + word);//word数组：[C@74a14482
        System.out.println("names数组：" + names);//names数组：[Ljava.lang.String;@1540e19d
    }
}

现在我们对一维数组的声明和初始化已经有了了解了，下面我们来看看怎么去使用它

一维数组的使用

我们在初始化的时候给了数组的长度和数组的元素，但是没有说怎么去获取到数组的长度和元素，下面我们来看看怎么去获取到这些。

• 数组的长度获取

数组名.length

直接就用数组名去点length就能知道数组的长度了。

• 如何获取数组中的一个元素？

每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引(index)或下标，可以通过数组的索引/下标访问到数组中的元素。就是下标的长度就是用数组的长度 -1就行，因为下标是从0开始的长度是从1开始的。这个也是数组下标的范围。Java中数组的下标从[0]开始，下标范围是[0, 数组的长度-1]，即[0, 数组名.length-1]

数组名[索引/下标]

• 一维数组的使用演示

public class Test03ArrayUse {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};

        System.out.println("arr数组的长度：" + arr.length);
        System.out.println("arr数组的第1个元素：" + arr[0]);//下标从0开始
        System.out.println("arr数组的第2个元素：" + arr[1]);
        System.out.println("arr数组的第3个元素：" + arr[2]);
        System.out.println("arr数组的第4个元素：" + arr[3]);
        System.out.println("arr数组的第5个元素：" + arr[4]);

        //修改第1个元素的值
        //此处arr[0]相当于一个int类型的变量
        arr[0] = 100;
        System.out.println("arr数组的第1个元素：" + arr[0]);
    }
}

注意：当访问数组元素时，下标指定超出[0, 数组名.length-1]的范围时，就会报数组下标越界异常：ArrayIndexOutOfBoundsException。

public class Test04ArrayIndexOutOfBoundsException {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
       // System.out.println("最后一个元素：" + arr[3]);//错误，下标越界ArrayIndexOutOfBoundsException
      //  System.out.println("最后一个元素：" + arr[arr.length]);//错误，下标越界ArrayIndexOutOfBoundsException
        System.out.println("最后一个元素：" + arr[arr.length-1]);//对
    }
}

在上面代码中的数组，赋值3个元素，数组的索引就是0，1，2，没有3的索引，因此我们不能访问数组中不存在的索引，程序运行后，将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

一维数组的遍历

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

public class Test05ArrayIterate {
    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]);
        }
    }
}

一维数组在内存中的存储

我们来看看一维数组在内存中是怎么样实现的。
上图我们能清晰的看出一维数组在内存中的运行流程。
数组还有几个常见的算法和排序，这章我们先不写，如果有想要了解的可以去看看我的冒泡排序博客，那个就是经典的数组算法。我们这个是了解数组的基本结构。下面我们来看看二维数组是怎么样的。

二维数组的声明

• 二维数组：本质上就是元素为一维数组的一个数组。
• 二维数组的标记：[][]

- int[][] arr; //arr是一个二维数组，可以看成元素是int[]一维数组类型的一维数组

只要能明白二维数组往后的三维、多维都没问题的。二维数组就是两个一维数组组合起来的。

二维数组声明的语法格式：

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

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

代码示例

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

        //存储多组姓名
        String[][] names;
    }
}

一维数组有动态静态初始化，那么二维数组也是有的。我们继续往下看

二维数组的静态初始化

静态初始化就是用静态数据（编译时已知）为数组初始化。

//以下格式要求声明与静态初始化必须一起完成
元素的数据类型[][] 二维数组的名称 = {
			{元素1，元素2，元素3 。。。}, 
			{第二行的值列表},
			...
			{第n行的值列表}
		};

元素的数据类型[][] 二维数组名 = new 元素的数据类型[][]{
			{元素1，元素2，元素3 。。。}, 
			{第二行的值列表},
			...
			{第n行的值列表}
		};

元素的数据类型[][] 二维数组名;
二维数组名 = new 元素的数据类型[][]{
			{元素1，元素2，元素3 。。。}, 
			{第二行的值列表},
			...
			{第n行的值列表}
		};

注意：如果是静态初始化，右边new 数据类型[][]中不能写数字，因为行数和列数，由{}的元素个数决定

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}};

arr = new int[3][3]{{1,2,3},{4,5,6},{7,8,9,10}};//错误，静态初始化右边new 数据类型[][]中不能写数字

二维数组静态初始化代码示例

public class Test21TwoDimensionalArrayInitialize {
    public static void main(String[] args) {
        //存储多组成绩
        int[][] grades = {
                    {89,75,99,100},
                    {88,96,78,63,100,86},
                    {56,63,58},
                    {99,66,77,88}
                };

        //存储多组姓名
        String[][] names = {
            {"张三","李四", "王五", "赵六"},
            {"刘备","关羽","张飞","诸葛亮","赵云","马超"},
            {"曹丕","曹植","曹冲"},
            {"孙权","周瑜","鲁肃","黄盖"}
        };
    }
}

我们现在知道二维数组的声明、初始化了那么下一步肯定是要知道怎么去使用了。

二维数组的使用

二维数组我们在使用是要清楚几个概念，它和一维数组是不一样的
二维数组的元素个数 = 二维数组中一维数组的个数 = arr.length;
二维数组的每个元素是一维数组, 所以如果需要得到每个一维数组中的元素，还需要再次遍历；
arr[i][j] =》 二维数组的第 i +1 个一维数组的第 j+1 个元素； eg: arr[0][0] = arr 中的第1个一维数组中的第1个元素。

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}
  		      };
	    }
  }

我们使用了肯定是要拿到这个里面的数据的。

二维数组遍历

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();
        }
    }
}

二维数组动态初始化

第一种方式（列数确定）

基本语法：
    类型[][] 数组名 = new 类型[大小][大小];
    举例: int arr[][] = new int[2][3];
    这种初始化方式在声明二维数组的同时开辟了其所需要的堆内存空间；

第二种方式（列数确定）

基本语法：

先声明：类型[][] 数组名;
再定义(开辟空间)：数组名 = new 类型[大小][大小];
然后给一维数组中的元素赋值，若不赋值，则为默认值。

第三种方式（列数不确定）

基本语法：

先声明：类型[][] 数组名;
再定义(开辟空间)：数组名 = new 类型[大小][]; 注意：此时一维数组未开辟堆内存空间；
遍历二维数组，给一维数组开辟堆内存空间，此时开辟的空间可以不相等；也就是列数不确定。
最后给一维数组中的元素赋值。

代码案例

/*
 1 1 1 1 1
 2 2 2 2 2
 3 3 3 3 3
 4 4 4 4 4
 */
public class Test24SameElementCount {
    public static void main(String[] args) {
        //1、声明二维数组，并确定行数和列数
        int[][] arr = new int[4][5];

        //2、确定元素的值
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                arr[i][j] = i + 1;
            }
        }

        //3、遍历显示
        for(int i=0; i<arr.length; i++){
            for(int j=0; j<arr[i].length; j++){
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

/*
 1
 2 2
 3 3 3
 4 4 4 4
 5 5 5 5 5
 */
public class Test25DifferentElementCount {
    public static void main(String[] args){
        //1、声明一个二维数组，并且确定行数
        //因为每一行的列数不同，这里无法直接确定列数
        int[][]  arr = new int[5][];

        //2、确定每一行的列数
        for(int i=0; i<arr.length; i++){
			/*
			arr[0] 的列数是1
			arr[1] 的列数是2
			arr[2] 的列数是3
			arr[3] 的列数是4
			arr[4] 的列数是5
			*/
            arr[i] = new int[i+1];
        }

        //3、确定元素的值
        for(int i=0; i<arr.length; i++){
            for(int j=0; j<arr[i].length; j++){
                arr[i][j] = i+1;
            }
        }

        //4、遍历显示
        for(int i=0; i<arr.length; i++){
            for(int j=0; j<arr[i].length; j++){
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }

    }
}

二维数组内存图

注意：如果是以动态初始化（列数不确定）的方式创建二维数组，例如：
int[][] arr = new int[3][]; 则此时所有的一维数组都没有开辟内存空间，它们的地址都为null；

二维数组的使用和注意细节
（1）一维数组的声明方式有: int[] x 或者 int x[] ；
（2）二维数组的声明方式有: int[][] y 或者 int[] y[] 或者 int y[][] ；
（3）二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。

比如： map[][] 是 一个二维数组， int[][] map = {{1,2},{3,4,5}} ；其中，map[0] 是一个含有两个元素的一维数组 ，map[1] 是一个含有三个元素的一维数组，因此， map[][] 也称为 “列数不等的二维数组”。

二维数组有个经典的案例杨辉三角大家看完可以去试试。

• 最后，如果本文有什么错漏的地方，欢迎大家批评指正！一起加油！！