22023.3.23——java数组的学习day4

1-数组介绍

• 介绍 : 是一种容器, 可以存储同种数据类型的多个值

同种数据类型 : 不要理解的太过于死板, 要结合隐式转换

double[] arr1 = {11.1, 22.2, 33};
System.out.println(arr1[2]);		// 33.0

int[] arr2 = {10, 20, 'a'};			
System.out.println(arr2[2]);		// 97

建议: 今后的数组容器, 还是尽量只存储同种数据类型

• 数组的使用场景 :

  • 发现要操作的数据有多个, 并且这多个数据属于同一组数据

---

2-数组的定义格式

• 数组定义格式
  • 格式一：数据类型[] 数组名
    范例：int[] array
  • java int[] arr;
  • 格式二：数据类型 数组名[]
    范例：int array[]
  • java int arr[];
• 注意事项 : 这种定义格式, 定义出来的, 只是数组类型的变量而已, 容器还没有被真正的创建

---

3-数组的静态初始化

• 初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程。
  • 范例：int[] array = new int[]{ 11，22，33 };
• 完整格式：数据类型[] 数组名 = new 数据类型[] { 元素1，元素2，元素3… };
  • 范例：double[] array2 = new double[] { 11.1，22.2，33.3};
• 静态初始化简化格式 :

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

int[] arr = {11,22,33,44,55};

---

4-数组的元素访问

• 格式 : 数组名[索引];

package com.itwx.array1;

public class ArrayDemo3 {
    /*
        数组的元素访问:

                格式 : 数组名[索引];
                索引(角标, 下标) : 数组容器中, 空间所对应的编号, 编号从0开始, 逐个 + 1 增长.
                ----------------------------------
                元素访问: 是让我们能够拿到真实的数据, 数据拿到手, 干什么都行.
     */
    public static void main(String[] args) {

        int[] arr = {11, 22, 33, 44, 55};
        System.out.println(arr);        // 数组的地址值

        // 元素访问: 数组中的22元素取出来进行打印
        System.out.println(arr[1]);

        // 元素访问: 数组中33元素, 修改为66
        arr[2] = 66;
        System.out.println(arr[2]);

        // 元素访问: 判断数组中的第一个元素, 是奇数还是偶数
        if (arr[0] % 2 == 0) {
            System.out.println(arr[0] + "是一个偶数");
        } else {
            System.out.println(arr[0] + "是一个奇数");
        }
        // 元素访问: 根据数组中第二个元素, 决定在控制台打印多少次HelloWorld
        for(int i = 1; i <= arr[1]; i++){
            System.out.println("HelloWorld");
        }

    }
}

---

5-数组的遍历操作

• 介绍 : 将数组中的 [每一个] 元素取出进行操作

package com.itwx.test;

public class ArrayTest1 {
    /*
        数组的遍历操作: 将数组中每一个元素, 取出来进行操作

        ----------------------------------------------

        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);

        弊端: 代码的重复度太高, 过于臃肿
        解决: 使用循环解决

        ----------------------------------------------

        for(int i = 0; i < 5; i++){
            System.out.println(arr[i]);
        }

        弊端: 循环次数写死了(硬编码)
        解决: 每一个数组中, 都存在一个属性 length
                使用方式: 数组名.length ---> 动态的获取到数组的长度
                长度: 数组中的元素个数

        ----------------------------------------------


        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }

     */
    public static void main(String[] args) {

        int[] arr = {11, 22, 33, 44, 55};

        // 遍历数组快捷键: 数组名.fori + 回车
        for (int i = 0; i < arr.length; i++) {
            // i : 索引
            // arr[i] : 数组中的元素
            System.out.println(arr[i]);
        }

    }
}

• 案例

package com.itwx.test;

public class ArrayTest4 {
    /*
        需求: 已知数组元素为 {11,22,33,44,55}

        1. 求出数组最大值
        2. 求出数组最小值
        3. 求出数组的总和
        4. 计算数组的平均值
        5. 将最大值, 最小值, 总和, 平均值打印在控制台
     */
    public static void main(String[] args) {

        int[] arr = {11, 22, 33, 44, 55};

        // 1. 求出数组最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }

        // 2. 求出数组最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }

        // 3. 求出数组的总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }

        // 4. 计算数组的平均值
        double avg = sum / (arr.length * 1.0);

        // 5. 将最大值, 最小值, 总和, 平均值打印在控制台
        System.out.println("最大值为:" + max);
        System.out.println("最小值为:" + min);
        System.out.println("总和为:" + sum);
        System.out.println("平均值为:" + avg);
    }
}

6-数组的动态初始化

• 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值
  • 格式：数据类型[] 数组名 = new 数据类型[数组长度];
    范例：int[] arr = new int[3];
    
• 两种初始化的区别
  • 动态初始化：手动指定数组长度，由系统给出默认初始化值
  • 静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度
• 案例

package com.wanxi.test;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

/*
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值

格式：数据类型[] 数组名 = new 数据类型[数组长度];
范例：int[] arr  = new int[3];

两种初始化的区别
动态初始化：手动指定数组长度，由系统给出默认初始化值。
静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度


需求：键盘录入5个整数并求出最大值
分析：
动态初始化数组，长度指定为5
循环遍历数组，在遍历的过程中，键盘录入整数并存入数组
求出数组最大值
打印数组

需求：产生10个1-100之间的随机数，并找出最大值
分析：
动态初始化数组，长度指定为10
循环遍历数组，在遍历的过程中，产生随机数并存入数组
遍历打印出数组现有元素
求出最大值
打印最大值

 */
public class ArrayDynamicInitialization {
    public static void main(String[] args) {
  /*      Scanner scanner = new Scanner(System.in);
        int[] arr = new int[5];
        int max = 0;
        for (int i = 0; i < arr.length; i++) {
            System.out.print("请输入第" + (i + 1) + "个整数");
            arr[i] = scanner.nextInt();
            max = max > arr[i] ? max : arr[i];
        }
        System.out.println("最大值为" + max);
        System.out.println(Arrays.toString(arr));*/
        System.out.println("--------------------------------------");
        Random random = new Random();
        int max1 = 0;
        int[] arr1 = new int[5];
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = random.nextInt(100) + 1;
            max1 = max1 > arr1[i] ? max1 : arr1[i];
        }
        System.out.println("最大值为："+max1);
        System.out.println(Arrays.toString(arr1));
    }
}

• 默认值的分类 :
  • 整数 : 0
    小数 : 0.0
    布尔 : false
    字符 : ‘\u0000’ —> Unicode字符 —> 常见的体现是空白字符
    引用数据类型 : null
    引用数据类型: 数组, 类, 接口

---

7-数组的内存图

如图

---

8-数组的常见问题

• 数组索引越界异常 : ArrayIndexOutOfBoundsException :
  • 原因 : 访问了不存在的索引
• 空指针异常 : NullPointerException :
  • 原因 : 当引用数据类型的变量, 记录到null之后, 代表跟堆内存的链接被切断了
    • 这时候还要去访问堆内存的数据, 就会出现空指针异常

9-二维数组介绍

• 介绍 : 二维数组也是一个容器, 容器中存储的都是一维数组
• 场景 : 发现要操作的数组, 有多个, 这多个数组也属于一个整体

某公司4个季度的销售额: 

int[][] arr = {
				{11,22,33},
				{11,55,22},
				{22,33,44},
				{77,11,33}
							}

---

10-二维数组静态初始化

• 完整格式 :

数据类型[][] 数组名 = new 数据类型[][] {
		{一维数组1},
		{一维数组2}
};

int[][] arr = new int[][] {
	{11,22,33},
	{44,55,66}
};

• 简化格式 :

数据类型[][] 数组名 = {
		{一维数组1},
		{一维数组2}
};

int[][] arr = {
	{11,22,33},
	{44,55,66}
};

• 二维数组的元素访问 :

格式 : 数组名[m索引][n索引];

m索引 : 要访问哪一个一维数组
n索引 : 访问一维数组中的哪一个元素

System.out.println(arr[0][1]);

---

11-二维数组的遍历操作

• 思路 :
  • 遍历二维数组, 获取到每一个一维数组
  • 继续遍历一维数组, 获取具体的元素

int[][] arr = {
	{11,22,33},
	{44,55,66}
};

// 遍历二维数组, 获取到每一个一维数组
for(int i = 0; i < arr.length; i++){
	// arr[i] : 代表每一个一维数组
	// 继续遍历一维数组, 获取具体的元素
	for(int j = 0; j < arr[i].length; j++){
		System.out.println(arr[i][j]);
	}
}

---

12-二维数组动态初始化

• 格式 :

数据类型[][] 数组名 = new 数据类型[m][n];

m : 指定这个二维数组, 可以存储多少个一维数组
n : 指定每一个一维数组中, 可以存储多少个元素

int[][] arr = new int[2][3];

这个二维数组, 可以存储2个一维数组, 每一个一维数组中可以存储3个元素

---

13-二维数组内存图

如图