05-数组

1. 数组（Array）

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

• 特点：

  1. 数组是一种引用数据类型。
  2. 数组中的多个数据，类型必须统一。
  3. 数组的长度在程序运行期间不可改变。

2. 数组的初始化

• 数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。
• 两种常见的初始化方式：
  1. 动态初始化（指定长度，不指定内容）
  2. 静态初始化（指定内容，不指定长度）

2.1. 动态初始化数组格式

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

• 解析含义：

1. 左侧数据类型：也就是数组当中保存的数据，全都是统一的一种类型。
2. 左侧的中括号：代表的是一组数组。
3. 左侧的数组名称：给数组取一个名字。
4. 右侧的new：代表创建数组的动作。
5. 右侧数据类型：必须和左侧的数据类型保持一致。
6. 右侧中括号的长度：也就是数据当中，到底可以保存多少个数据，是一个int数字。

• 例如：创建一个数组，里面可以存放300个int类型的数据；创建一个数组，里面可以存放10个double类型的数据；创建一个数据，里面存5个字符串。

package cn.itcast.day05;

public class Demo01Array {
    public static void main(String[] args) {
        // 创建一个数组，里面可以存放300个int类型的数据
        int [] arrayA = new int [300];
        // 创建一个数组，里面可以存放10个double类型的数据
        double [] arrayB = new double[10];
        //创建一个数据，里面存5个字符串
        String[] arrayC = new String[5];
    }
}

2.2. 静态初始化数组

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

• 例如：创建一个数组，里面装的全部都是int类型，具体为：5，15，25；创建一个数组，来装字符串：“Hello”，“World”，“Java”。

package cn.itcast.day05;

public class Demo02Array {
    public static void main(String[] args) {
        // 创建一个数组，里面装的全部都是int类型，具体为：5，15，25
        int[] arrayA = new int[] {5, 15, 25};
        // 创建一个数组，来装字符串：“Hello”，“World”，“Java”
        String[] arrayB = new String[] {"Hello", "World", "Java"};
    }
}

2.3. 省略的静态初始化

1. 标准格式：数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，...};
2. 省略模式：数据类型[] 数组名称 = {元素1，元素2，...}; 例如：

package cn.itcast.day05;

public class Demo03Array {
    public static void main(String[] args) {
        int[] arrayA = {10, 20, 30};
    }
}

• 注意事项：

1. 静态初始化没有直接指定长度，但是仍然会自动推算得到长度。

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

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

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

package cn.itcast.day05;

public class Demo03Array {
    public static void main(String[] args) {
        // 静态初始化标准格式可以拆分成为两个步骤:
        int [] arrayB;
        arrayB = new int[] {11, 21, 31};

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

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

3. 数组中的元素

3.1. 访问数组元素进行获取

1. 直接打印数组名称：得到的是数组对应的内存地址的哈希值。
2. 访问数组元素的格式：数组名称[索引值];
3. 索引值从零开始，一直到“数组长度-1”为止。

package cn.itcast.day05;

public class Demo04ArrayUse {
    public static void main(String[] args) {
        int[] array = {10, 20, 30};
        System.out.println(array); // 得到的是内存中的地址的哈希值：[I@6acbcfc0
        // 直接打印数组中的元素：
        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
    }
}

3.2. 访问数组元素进行赋值

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

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

package cn.itcast.day05;

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("======================");

        array[1] = 123;
        System.out.println(array[0]); // 0
        System.out.println(array[1]); // 123
        System.out.println(array[2]); // 0
    }
}

• 注意事项：静态初始话其实也有默认值的过程，只不过系统会自动马上将默认值替换晟为大括号中的具体数值。

4. Java的内存

• java的内存分为五个部分（现在先关注前三个内存，后两个现在不具体说）：

  1. 栈（Stack）：存放的都是方法中的局部变量。方法运行在栈当中。

     局部变量：方法的参数，或者是方法{}内部的变量。

     作用域：一旦超出作用域，立马从栈中消失。

  2. 堆（Heap）：凡是new出来的东西，都在堆当中。

     堆内存里面的东西都有一个地址值，为十六进制。

     堆内存里卖弄的数据，都有默认值，规则：如果是帧数，默认为0；如果是浮点数，默认为0.0；如果是字符，默认为‘/u0000’；如果是布尔值，默认为false；如果是引用类型，没认为null。

  3. 方法区（Method Area）：存储.class相关信息，包含方法的信息。

  4. 本地方法栈（Native Method Stack）：与操作系统有关，现在不展开说。

  5. 寄存器（PC Register）：与CPU相关，现在不展开说。

4.1. 一个数组的内存图

4.2. 两个数组的内存图

• 从以上的内存图可知：这两个数组没有任何联系。接下来让这连个数组产生一些联系。

4.3. 两个引用指向同一个内存图

• 和上面区别在于左侧红框里的代码

4.4. 空指针异常

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

package cn.itcast.day05.demo03;

public class Demo02ArrayNull {
    public static void main(String[] args) {
        // 会抛出空指针异常！
        int[] array = null;
        System.out.println(array[0]);
    }
}

4.5. 获取数组的长度

• 格式：数组名称.length

• 注意：数组一旦创建，程序运行期间，长度不可以改变！！！这点和Python不一样！！！

![5](C:\Users\zhuwe\OneDrive\Desktop\5.png)package cn.itcast.day05.demo03;

public class Demo03ArrayLength {
    public static void main(String[] args) {
        int[] arrayB = {10, 20, 30, 3, 5, 4, 6, 9, 9};
        int len = arrayB.length;
        System.out.println("arrayB数组长度：" + len);
        System.out.println("=======================");

        // 这是两个不一样的数组，因为进行了两次new！！！具体看下面的内存图
        int[] arrayC = new int[3];
        System.out.println(arrayC.length);
        // 这是一个新的数组arrayC！！！
        arrayC = new int[5];
        System.out.println(arrayC.length);
    }
}

4.6. 遍历数组

• 用for循环遍历数组如下：

package cn.itcast.day05.demo04;

public class Demo04Array {
    public static void main(String[] args) {
        int[] array = {15, 25, 30, 40, 50};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

• 练习01：求出数组中的最大值。

package cn.itcast.day05.demo04;

public class Demo04ArrayMax {
    public static void main(String[] args) {
        int[] array = {5, 15, 30, 20, 10000};
        int max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        System.out.println("最大值为：" + max);
    }
}

• 练习02：反转一个数组

package cn.itcast.day05.demo04;

public class Demo07ArrayReverse {
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50,};
        // 遍历数组本来的样子：
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("=====================");
        /*
        初始化语句：int min = 0, max = array.length - 1;
        条件判断：min < max;
        步进表达式：min++, max--
        循环体：
        */
        // 数组的反转：
        for (int min = 0, max = array.length - 1; min < max; min++, max--) {
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }
        // 数组反转之后的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

4.7. 数组作为方法参数–传递地址

• 数组可以作为方法中的参数；当调用的方法的时候，向小括号进行传参，传递进去的其实是数组的地址值。

package cn.itcast.day05.Demo01;

public class ArrayParam {
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50, 60};
        printArray(array);
    }
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

4.8. 数组作为返回值

package cn.itcast.day05.Demo01;

public class Demo02ArrayParam {
    public static void main(String[] args) {
        int[] result = calculate(10, 20, 30);
        System.out.println("总和：" + result[0]);
        System.out.println("平均值：" + result[1]);
    }
    
    public static int[] calculate(int a, int b, int c) {
        int sum = a + b +c;
        int avg = sum / 3;
        int[] array = new int[2];
        array[0] = sum;
        array[1] = avg;
		// 数组作为返回值：
        return array;
    }
}