【Java基础】04 数组

数组的定义

数组就是用来存储一批同种类型数据的容器。

// 20, 10, 80, 60, 90
int[] arr = {20, 10, 80, 60, 90};

// 牛二, 西门, 全蛋
String[] names = {"牛二", "西门", "全蛋"};

关于数组需要学会什么？
1. 怎么定义数组存储数据：在程序中如何去定义数组存储数据，具体格式是什么样的
2. 怎么操作数组元素：怎么去获取，修改数组中的数据
3. 怎么解决实际问题：怎么结合数组解决比如随机点名等一些实际业务
4. 数组内存原理：数组在内存中具体是怎么去工作的
5. 数组使用的注意点：避免入坑，同时可以在出现问题后立即排查问题所在

静态初始化数组

定义数组的时候直接给数组赋值。

静态初始化数组的格式：

// 完整格式
数据类型[] 数组名 = new 数据类型[]{元素1，元素2 ，元素3… };
double[] scores = new double[]{89.9, 99.5, 59.5, 88.0};
int[] ages = new int[]{12, 24, 36};

1
2
3

// 简化格式
数据类型[] 数组名 = { 元素1，元素2 ，元素3，… };
int[] ages = {12, 24, 36};

数组的基本原理：数组变量名中存储的是数组在内存中的地址信息，数组是引用数据类型。
1
2
3
int[] ages = {12, 24, 36};
System.out.println(ages); // [I@1b6d3586
System.out.println(ages[0]); // 12

数组的访问

数组名称[索引]

// 取值
System.out.println(arr[0]); // 12
// 赋值
arr[2] = 100;
System.out.println(arr[2]); // 100

数组的长度属性：length

1 2	// 获取数组的长度（就是数组元素的个数） System.out.println(arr.length); // 3

数组的最大索引可以怎么表示？

1	数组名.length – 1 // 前提：元素个数大于0

数组的几个注意事项

数据类型[] 数组名也可以写成数据类型数组名[]

int[] ages =...;  
int ages[] =...;  

double[] scores = ...;
double scores[] = ...;

什么类型的数组存放什么类型的数据，否则报错
1
int[] arrs = new int[]{30, 40, "高圆圆"};
数组一旦定义出来，程序执行的过程中，长度、类型就固定了

动态初始化数组

定义数组的时候只确定元素的类型和数组的长度，之后再存入具体数据

数组的动态初始化格式

1 2	数据类型[] 数组名 = new 数据类型[长度]; int[] arr = new int[3];

1
2
3

// 后赋值
arr[0] = 10;
System.out.println(arr[0]); // 10

两种数组定义时的特点和场景有什么区别
1. 当前已经知道存入的元素值，用静态初始化
2. 当前还不清楚要存入哪些数据，用动态初始化

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

数据类型	明细	默认值
基本类型	byte、short、char、int、long	0
基本类型	flout、double	0.0
基本类型	boolean	false
引用类型	类，接口，数组，String	null

两种初始化的的使用场景总结、注意事项说明：
- 动态初始化：只指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景。
- 静态初始化：开始就存入元素值，适合一开始就能确定元素值的业务场景。
- 两种格式的写法是独立的，不可以混用。int[] arrs = new int[3]{30，40,50};

// 先创建
int[] arr = new int[3];

// 再赋值
System.out.println(arr[0]); // 默认是0
arr[0] = 10;
System.out.println(arr[0]); // 赋值后是10

数组的遍历

遍历：就是一个一个数据的访问。

int[] ages = {20, 30, 40, 50};
for (int i = 0; i < ages.length; i++) {
  System.out.println(ages[i]);
}

数组的案例

数组元素求和

需求：某部门5名员工的销售额分别是：16、26、36、6、100，请计算出他们部门的总销售额。

package study;

/**
 * 数组案例：遍历求和
 */
public class Demo4 {
    public static void main(String[] args) {
        int[] arr = {16, 26, 36, 6, 100};
        int res =0;

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

数组求最值

数组元素求最大值如何实现？
1. 数据拿到程序中去，用数组装起来。
2. 定义一个变量用于记录最大值，这个变量建议默认存储第一个元素值作为参照。
3. 遍历数组的元素，如果该元素大于变量存储的元素，则替换变量存储的值为该元素。
4. 循环结束后输出最大值变量即可。

package study;

/**
 * 数组案例：求最值
 */
public class Demo5 {
    public static void main(String[] args) {
        int[] scores = {15, 9000, 10000, 20000, 9500, -5};
        // 定义一个变量用于记录最大值，存储第一个元素值作为参照
        int max = scores[0];

        for (int i = 1; i < scores.length; i++) {
            if (scores[i] > max) {
                // 替换
                max = scores[i];
            }
        }

        System.out.println(max);
    }
}

猜数字游戏

需求
- 开发一个幸运小游戏，游戏规则如下：
- 游戏后台随机生成1-20之间的5个数（无所谓是否重复），然后让大家来猜数字：
- 未猜中提示：“未命中”，并继续猜测
- 猜中提示：“运气不错，猜中了”，并输出该数据第一次出现的索引位置，最后把数组中的5个数据都输出看以下，然后结束本游戏。
猜数字游戏的实现步骤？
1. 动态初始化数组，存入5个随机的1-20之间的数据。
2. 定义一个死循环，不断的猜数据。
3. 遍历数组，判断数据是否在数组中，如果在，进行对应提示并结束死循环；如果没有猜中，提示继续。

方法一：猜中时，使用return;直接结束main方法

package study;

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

/**
 * 数组案例：猜数字游戏
 */
public class Demo6 {
    public static void main(String[] args) {
        // 定义长度为5的数组
        int[] numArr = new int[5];

        // 随机生成5个数
        Random random = new Random();
        for (int i = 0; i < numArr.length; i++) {
            // 先生成0~19的随机数，加1后范围变成1~20
            int nums = random.nextInt(20) + 1;
            numArr[i] = nums;
        }

        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("猜个数(1~20)：");
            int guess = scanner.nextInt();
            // 循环遍历数组
            for (int i = 0; i < numArr.length; i++) {
                if (numArr[i] == guess) {
                    System.out.println("运气不错，猜中了！");
                    System.out.println("该数第一次出现的索引位置：" + i);
                    System.out.print("这五个数分别是：");
                    for (int j = 0; j < numArr.length; j++) {
                        System.out.print(numArr[j] + ",");
                    }
                    return; // 跳出所有循环，直接结束main方法
                }
            }
            System.out.println("没有这个数，换一个吧！");
        }
    }
}

方法二：给while起个名字a，猜中时，使用break a;直接结束while循环

Scanner scanner = new Scanner(System.in);
// 开始猜数字
a:
while (true) {
    System.out.println("猜个数(1~20)：");
    int guess = scanner.nextInt();
    // 循环遍历数组
    for (int i = 0; i < numArr.length; i++) {
        if (numArr[i] == guess) {
            System.out.println("运气不错，猜中了！");
            System.out.println("该数第一次出现的索引位置：" + i);
            System.out.print("这五个数分别是：");
            for (int j = 0; j < numArr.length; j++) {
                System.out.print(numArr[j] + ",");
            }
            break a; // 找到了数字a，结束循环
        }
    }
    System.out.println("没有这个数，换一个吧！");
}

break只能跳出当前循环，要想跳到指定的循环，需用标记。A：是A循环；break A：表示跳出A循环。

随机排名

需求
- 某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。
- 请先依次录入5名员工的工号，然后展示出一组随机的排名顺序。
分析
1. 在程序中录入5名员工的工号存储起来 —> 使用数组。
2. 依次遍历数组中的每个元素，随机一个索引数据，让当前元素与该索引位置处的元素进行交换。

package study;

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

/**
 * 数组案例：随机排名
 */
public class Demo7 {
    public static void main(String[] args) {
        int[] jobNumbers = new int[5];
        Scanner scanner = new Scanner(System.in);
        // 录入工号
        for (int i = 0; i < jobNumbers.length; i++) {
            System.out.println("请录入第" + (i + 1) + "位员工的工号：");
            int number = scanner.nextInt();
            jobNumbers[i] = number;
        }
        System.out.println("录入完成，工号分别为：");
        for (int i = 0; i < jobNumbers.length; i++) {
            System.out.print(jobNumbers[i] + ",");
        }
        System.out.println();

        // 遍历数组
        Random random = new Random();
        for (int i = 0; i < jobNumbers.length; i++) {
            // 随机生成一个索引（生成0~4的随机数）
            int randomIndex = random.nextInt(5);

            // 与当前索引对应的值进行交换
            int temp = jobNumbers[i]; // 临时变量，储存当前索引对应的元素
            jobNumbers[i] = jobNumbers[randomIndex]; // 当前索引对应的元素，值替换成随机生成的索引对应的元素
            jobNumbers[randomIndex] = temp; // 随机生成的索引对应的元素，值替换成当前索引刚才对应的元素
        }

        System.out.println("随机完成，顺序分别为：");
        for (int i = 0; i < jobNumbers.length; i++) {
            System.out.print(jobNumbers[i] + ",");
        }
    }
}

录入完成，工号分别为：
22,33,35,13,88,
随机完成，顺序分别为：
35,22,33,88,13,

打乱顺序随机排名(随机排序)的其他使用场景：打乱扑克牌

数组的内存图

Java内存分配、数组内存图

两个变量指向同一个数组

数组使用的常见问题

如果访问的元素位置超过最大索引，执行时会出现ArrayIndexOutOfBoundsException(数组索引越界异常)
1
2
3
int[] arr = new int[]{11, 22, 33};
System.out.println(arr[2]);
// System.out.println(arr[3]) // 出现异常
如果数组变量中没有存储数组的地址，而是null, 在访问数组信息时会出现NullPointerException(空指针异常)
1
2
3
arr = null;
System.out.println(arr); // null
System.out.println(arr.length) // 出现异常

Debug工具的使用

IDEA自带的断点调试(排错)工具，可以控制代码从断点开始一行一行的执行，然后详细观看程序执行的情况。
DEBUG工具基本使用步骤
1. 在需要控制的代码行左侧，点击一下，形成断点
2. 在代码行右键选择使用Debug方式启动程序，启动后程序会在断点暂停
3. 点击控制台Step Over小按钮控制代码一行一行的往下执行