Java语言基础Day05（数组）

---

一、数组的概念

• 数组的概念：是一种容器，可以同时存放多个数据值。

• 数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。
  即：数(数据)组(一组)就是一组数据

• 数组的特点：

  数组是一种引用数据类型

  数组当中的多个数据，类型必须统一

  数组的长度在程序运行期间不可改变

二、数组的定义格式

1.动态初始化

• 数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。

• 两种常见的初始化方式：

  动态初始化（指定长度）

  静态初始化（指定内容）

动态初始化数组的格式：

数据类型[] 数组名称 = new 数据类型[数组长度];
数据类型 数组名称[] = new 数据类型[数组长度];

• 解析含义：

  左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型

  左侧的中括号：代表我是一个数组

  左侧数组名称：给数组取一个名字

  右侧的new：代表创建数组的动作

  右侧数据类型：必须和左边的数据类型保持一致

  右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字

public class Demo01Array {
   

    public static void main(String[] args) {
   
        // 创建一个数组，里面可以存放300个int数据
        // 格式：数据类型[] 数组名称 = new 数据类型[数组长度];
        int[] arrayA = new int[300];

        // 创建一个数组，能存放10个double类型的数据
        double[] arrayB = new double[10];

        // 创建一个数组，能存放5个字符串
        String[] arrayC = new String[5];
    }

}

2.静态初始化

• 动态初始化（指定长度）：在创建数组的时候，直接指定数组当中的数据元素个数。

• 静态初始化（指定内容）：在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。

静态初始化基本格式：

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

• 注意事项：

  虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内
  容，也可以自动推算出来长度。

public class Demo02Array {
   

    public static void main(String[] args) {
   
        // 直接创建一个数组，里面装的全都是int数字，具体为：5、15、25
        int[] arrayA = new int[] {
    5, 15, 25, 40 };

        // 创建一个数组，用来装字符串："Hello"、"World"、"Java"
        String[] arrayB = new String[] {
    "Hello", "World", "Java" };
    }

}

3.省略的静态初始化

• 使用静态初始化数组的时候，格式还可以省略一下。

标准格式：

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

省略格式：

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

• 注意事项：
  静态初始化没有直接指定长度，但是仍然会自动推算得到长度。

  静态初始化标准格式可以拆分成为两个步骤。

  动态初始化也可以拆分成为两个步骤。

  静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。

• 使用建议：

  如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。

public class Demo03Array {
   

    public static void main(String[] args) {
   
        // 省略格式的静态初始化
        int[] arrayA = {
    10, 20, 30 };

        // 静态初始化的标准格式，可以拆分成为两个步骤
        int[] arrayB;
        arrayB = new int[] {
    11, 21, 31 };

        // 动态初始化也可以拆分成为两个步骤
        int[] arrayC;
        arrayC = new int[5];

        // 静态初始化的省略格式，不能拆分成为两个步骤。
//        int[] arrayD;
//        arrayD = { 10, 20, 30 };
    }

}

三、访问数组元素进行获取

• 直接打印数组名称，得到的是数组对应的：内存地址哈希值。
• 二进制：01
• 十进制：0123456789
• 16进制：0123456789abcdef

访问数组元素的格式：

数组名称[索引值];

• 索引值：就是一个int数字，代表数组当中元素的编号。
• 【注意】索引值从0开始，一直到“数组的长度-1”为止。

public class Demo04ArrayUse {
   

    public static void main(String[] args) {
   
        // 静态初始化的省略格式
        int[] array = {
    10, 20, 30 };

        System.out.println(array); // [I@75412c2f

        // 直接打印数组当中的元素
        System.out.println(array[0]); // 10
        System.out.println(array[1]); // 20
        System.out.println(array[2]); // 30
        System.out.println("=============");

        // 也可以将数组当中的某一个单个元素，赋值交给变量
        int num = array[1];
        System.out.println(num); // 20
    }

}

四、访问数组元素进行赋值

• 使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。规则如下：

  如果是整数类型，那么默认为0；
  如果是浮点类型，那么默认为0.0；
  如果是字符类型，那么默认为’\u0000’；
  如果是布尔类型，那么默认为false；
  如果是引用类型，那么默认为null。

• 注意事项：

  静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数值。

public class Demo05ArrayUse {
   

    public static void main(String[] args) {
   
        // 动态初始化一个数组
        int[] array = new int[3];

        System.out.println(array); // 内存地址值
        System.out.println(array[0]); // 0
        System.out.println(array[1]); // 0
        System.out.println(array[2]); // 0
        System.out.println("=================");

        // 将数据123赋值交给数组array当中的1号元素
        array[1] = 123;
        System.out.println(array[0]); // 0
        System.out.println(array[1]); // 123
        System.out.println(array[2]); // 0
    }

}

五、Java中的内存划分

六、一个数组的内存图

1.改变数组中的元素之前：

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

2.改变数组中的元素之后：

根据名称找到array这个数组
array[1]顺着内存地址，将索引值为1的默认值改为10
array[2]顺着内存地址，将索引值为2的默认值改为20

七、两个数组的内存图

八、两个引用指向同一个数组的内存图

九、数组常见问题

1.数组索引越界异常

• 数组的索引编号从0开始，一直到“数组的长度-1”为止。

• 如果访问数组元素的时候，索引编号并不存在，那么将会发生数组索引越界异常（ArrayIndexOutOfBoundsException）

• 原因：索引编号写错了。

• 解决：修改成为存在的正确索引编号。

        public class Demo01ArrayIndex {
   

            public static void main(String[] args) {
   
                int[] array = {
    15, 25, 35 };

                System.out.println(array[0]); //15
        System.out.println(array[1]); // 25
        System.out.println(array[2]); // 35

        // 错误写法
        // 并不存在3号元素，所以发生异常
        System.out.println(array[3]);
    }

}

2.空指针异常

• 所有的引用类型变量，都可以赋值为一个null值。但是代表其中什么都没有。
• 数组必须进行new初始化才能使用其中的元素。
• 如果只是赋值了一个null，没有进行new创建，那么将会发生：空指针异常 （NullPointerException）
• 原因：忘了new
• 解决：补上new

public class Demo02ArrayNull {
   

    public static void main(String[] args) {
   
        int[] array = null;
//        array = new int[3];
        System.out.println(array[0]);
    }

}

十、获取数组的长度

如何获取数组的长度，格式：

数组名称.length

这将会得到一个int数字，代表数组的长度。

数组一旦创建，程序运行期间，长度不可改变。

public class Demo03ArrayLength {
   

    public static void main(String[] args) {
   
        int[] arrayA = new int[3];

        int[] arrayB = {
   10, 20, 30, 3, 5, 4, 6, 7, 8, 8, 65, 4, 44, 6, 10, 3, 5, 4, 6, 7, 8, 8, 65, 4};
        int len = arrayB.length;
        System.out.println("arrayB数组的长度是：" + len);
        System.out.println("=============");

        int[] arrayC = new int[3];
        System.out.println(arrayC.length); // 3
        arrayC = new int[5];
        System.out.println(arrayC.length); // 5
    }

}

内存原理图：

十一、数组的遍历输出

遍历数组，说的就是对数组当中的每一个元素进行逐一、挨个儿处理。默认的处理方式就是打印输出。

public class Demo04Array {
   

    public static void main(String[] args) {
   
        int[] array = {
    15, 25, 30, 40, 50, 60, 75 };

        // 首先使用原始方式
        System.out.println(array[0]); // 15
        System.out.println(array[1]); // 25
        System.out.println(array[2]); // 30
        System.out.println(array[3</