public class TestDemo02 {
    public static void main(String[] args) {
        //1.动态初始化：创建数组时直接指定数组中元素个数
        int[] array = new int[10];
        //2.静态初始化：在创建数组时直接不指定数组元素个数，
        //而是将数组内容指定，编译器会自动确定数组长度
        int[] array1 = new int[]{0,2,3,4,6,7};
        //也可以简写一下，把后面的new int[]省略
        //这是因为编译器，编译时会把这个自动还原出来
        int[] array2 = {0,3,5,6,2,6,9};   
    }
}

建议如果确定数组内容那就使用第二种，更简单，如果不确定就使用第一种

当然了，对数组初始化也可以分为两步：

public class TestDemo02 {
public static void main(String[] args) {
    //1.动态初始化，分两步
    int[] array1;
    array1 = new int[10];
    //2.静态初始化，分两步（不能省略new int[]）
    int[] array2;
    array2 = new int[]{4,6,2,8,9};
}
}

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

1.3 数组的使用

1.3.1要访问数组中的元素

可以通过数组下标访问任意位置的元素，因为数组在内存中是一段连续的空间，空间的编号是从0开始的。所以可以随机访问，任意位置的元素

大家可以看

通过数组下标果然可以，访问数组元素，并且也可以通过数组下标来改变数组中的元素

这里再说明一种情况，如果访问的数组越界，就会报这样的错误，所以在访问数组时，就要注意这种情况

1.3.2 遍历数组元素

遍历数组元素就将数组中的元素访问一遍，比如访问一遍然后打印出来

这里就可以使用前面学过的循环了，比如for循环

public class TestDemo02 {
public static void main(String[] args) {
    int[] array = new int[]{10,20,60,45,67};
    for(int i = 0;i<5;i++){
        System.out.println(array[i]);
    }
}

这里再也可以通过 数组名.length 来获取数组的长度

public class TestDemo02 {
public static void main(String[] args) {
    int[] array = new int[]{10,20,60,45,67};
    for(int i = 0;i<array.length;i++){
        System.out.println(array[i]);
    }
}

遍历数组也可以使用 for-each

但这种方法遍历出来的数组没有下标，有一定局限性

public class TestDemo02 {
public static void main(String[] args) {
    int[] array = {1,56,23,45,88};
    for(int x:array){
        System.out.println(x);
    }
}
}

2. 数组是引用类型

2.1 初始JVM的内存分布

内存中需要存储很多的数据，比如

程序中的常量保存；运行时代码需要加载在内存上，并且中间产生的数据也要放在内存中，

所以有很多种的数据要存储在内存中，为了提高内存中的存储效率，

所以在JVM中对内存按照功能进行了管理

2.2 区分基本类型变量和引用类型变量

public class TestDemo02 {
public static void func() {
    int a = 18;
    int b = 88;
    int[] array = new int[]{1,56,2,51};
}
}

基本数据类型，就是直接创建的变量，然后在变量空间里存放给赋的值。

也就是a,b, 在对应的栈帧空间里赋予18.88

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

也就是array数是引用类型，然后内部保存的是数组在堆空间中的首地址

下面看道题，细致分析一下，会输出什么


public static void func(String[] args) {
    int[] array1 = new int[3];
    array1[0] = 10;
    array1[1] = 20;
    array1[2] = 30;
    
    int[] array2 = new int[]{1,2,3,4,5};
    array2[0] = 100;
    array2[1] = 200; 
    
    array1 = array2;
    array1[2] = 300;
    array1[3] = 400; 
    array2[4] = 500;
    for (int i = 0; i < array2.length; i++) {
        System.out.println(array2[i]);
    }
}

2.3认识Java中的NULL

java中NULL 表示空引用，也就是不指向对象的引用

表示一个无效的内存位置，所以不能对这个内存进行任何读写的操作，不然会报错

3. 实际使用数组

我们刚开始学数组，就是说数组是一些相同元素的一种类型集合

所以数组就是用来保存数据的

3.1 数组作为函数参数

数组array作为函数的参数，传递给print。

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

下面再看一个

引用数据类型（本质实际上传的是地址）

（1）修改自己的指向

（2）通过当前引用修改原来的值

3.2 数组作为函数的返回值

4. 认识二维数组

二维数组本质上就是一维数组，其每个元素又是一个一维数组。

数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

下面看一下，二维数组定义的三种方式

    int[][] array1 = {{1,2,3},{2,8,6}};
    int[][] array2 = new int[2][3];
    int[][] array3 = new int[][]{{1,2,3},{2,8,6}};

下面看一下二维数组打印的方式

第一种for循环遍历

public class TestDemo02 {
public static void main(String[] args) {
    int[][] array1 = {{1,2,3},{2,8,6}};
    for (int i = 0; i < array1.length; i++) {
        for (int j = 0; j < array1[i].length; j++) {
            System.out.print(array1[i][j]+" ");
        }
        System.out.println();
    }
}
}

第二种for-each遍历

public class TestDemo01 {
    public static void main(String[] args) {
        int[][] array = {{1,2,3},{4,5,6}};
        int[][] array2 = new int[][]{{7,8,9},{1,2,3}};
        int[][] array3 = new int[2][3];

        for (int[] tmp: array) {
            for (int x: tmp) {
                System.out.print(x + " ");
            }
        }
    }
}

第三种遍历方式

java中有一个操作数组的类Arrays.deepToString（）

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

        System.out.println(Arrays.deepToString(array));
    }
}

注意区分：在java中可以省略列不能省略行

在C语言中可以省略行不能省略列

这里再提一个 不规则数组

因为这里在刚开始定义二维数组是省略了列，然后再单独对每一行进行定义，然后就可以给每一行定义不同的列

public class TestDemo01 {
public static void main(String[] args) {
    int[][] array = new int[2][];
    array[0] = new int[3];
    array[1] = new int[5];
    System.out.println(Arrays.deepToString(array));
}
}