Java程序设计--数组（四）

---

1、数组的定义

1.1 什么是数组

数组就是用来存储一批同种类型数据的内存区域(可以理解成容器)。

1.2 数组定义格式

第一种

​ 数据类型[] 数组名

​ 示例：

int[] arr;        
double[] arr;      
char[] arr;

第二种

​ 数据类型 数组名[]

​ 示例：

int arr[];
double arr[];
char arr[];

1.3 静态化初始化数组

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

静态初始化格式

• 完整版格式

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

• 简化版格式

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

示例代码：

public class ArrayDemo {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1, 2, 3};

        //输出数组名
        System.out.println(arr);

        //输出数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

数组变量名中存储的是数组在内存中的地址，数组是引用类型。

数组元素访问

• 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。
• ​ 这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。
• 数组的最大索引可以表示为：数组名.length - 1（前提是元素个数大于0）

访问数组元素格式

数组名[索引];

示例代码：

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

        //输出数组名
        System.out.println(arr); //[I@880ec60

        //输出数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

数组的几个注意事项：

• “数据类型[] 数组名”也可以写成“数据类型 数组名[]”。
• 什么类型的数组存放什么类型的数据，否则报错。
• 数组一旦定义出来，程序执行的过程中，长度、类型就固定了 。

1.4 数组动态初始化

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

动态初始化格式

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

int[] arr = new int[3];

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

元素默认值

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

---

2、数组的遍历

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

public class ArrayDemo {
    public static void main(String[] args) {
        // 目标：学会进行数组元素的遍历
        int[] arr = {12, 24, 12, 48, 98};
        //           0    1   2   3   4

        // 原始遍历方式
//        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]);
//        }

        // 终极数组遍历形式
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

---

3、数组的案例

数组元素求和

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

public class Test1 {
    public static void main(String[] args) {
        // 需求：数组元素求和
        // 1、把这些数据拿到程序中使用数组记住
        int[] money = {16, 32, 8, 100, 78};

        // 3、定义一个求和变量累加数组的元素值
        int sum = 0;

        // 2、遍历数组中的每个元素
        for (int i = 0; i < money.length; i++) {
            // 拿到每个元素值累加
            sum += money[i];
        }

        // 4、输出求和变量即可
        System.out.println("数组的元素和是：" + sum);
    }
}

数组求最值

public class Test2 {
    public static void main(String[] args) {
        // 需求：数组元素求最值。

        // 1、定义一个静态初始化的数组，存储一批颜值。
        int[] faceScore = {15, 9000, 10000, 20000, 9500, -5};
        //                 0    1      2     3      4    5

        // 2、定义一个变量用于存储最大值元素，建议使用第一个元素作为参照。
        int max = faceScore[0];

        // 3、遍历数组的每个元素，依次与最大值变量的数据比较，若较大，则替换。
        for (int i = 1; i < faceScore.length; i++) {
            if(faceScore[i] > max){
                max = faceScore[i];
            }
        }

        // 4、输出最大值变量存储的数据即可。
        System.out.println("数组的最大值是：" + max);
    }
}

猜数字游戏

开发一个幸运小游戏，游戏规则如下:
游戏后台随机生成1-20之间的5个数（无所谓是否重复)，然后让大家来猜数字:

• 未猜中提示:“未命中”，并继续猜测
• 猜中提示:“运气不错，猜中了”，并输出该数据第一次出现的位置，且输出全部5个数据，

最终结束本游戏。

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

public class Test3 {
    public static void main(String[] args) {
        // 需求：5个 1-20之间的随机数，让用户猜测，猜中要提示猜中，还要输出该数据在数组中第一次出现的索引，并打印数组的内容出来。
        // 没有猜中继续。

        // 1、定义一个动态初始化的数组存储5个随机的1-20之间的数据
        int[] data = new int[5];

        // 2、动态的生成5个1-20之间的随机数并存入到数组中去。
        Random r = new Random();
        for (int i = 0; i < data.length; i++) {
            // i = 0 1 2 3 4
            data[i] = r.nextInt(20) + 1;
        }

        // 3、使用一个死循环让用户进行猜测
        Scanner sc = new Scanner(System.in);
        OUT:
        while (true) {
            System.out.println("请您输入一个1-20之间的整数进行猜测：");
            int guessData = sc.nextInt();

            // 4、遍历数组中的每个数据，看是否有数据与猜测的数据相同，相同代表猜中了，给出提示
            for (int i = 0; i < data.length; i++) {
                if(data[i] == guessData){
                    System.out.println("您已经猜中了该数据，运气不错了！您猜中的数据索引是：" + i);
                    break OUT; // 结束了整个死循环，代表游戏结束了！
                }
            }
            System.out.println("当前猜测的数据在数组中不存在，请重新猜测！");
        }

        // 5、输出数组的全部元素，让用户看到自己确实是猜中了某个数据。
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + "\t");
        }
    }
}

随机排名

某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。请先依次录入5名员工的工号，然后展示出一组随机的排名顺序。

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

public class Test4 {
    public static void main(String[] args) {
        // 目标：键盘录入一组工号，最终要随机输出一组出来作为排名
        // 1、动态初始化一个数组，存储5个工号
        int[] codes = new int[5];

        // 2、定义一个循环，循环5次，依次录入一个工号存入对应的位置
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < codes.length; i++) {
            // 正式录入工号
            System.out.println("请您输入第" + (i + 1) + "个员工的工号：");
            int code = sc.nextInt();
            // 存入到数组中去
            codes[i] = code;
        }

        // 3、遍历数组中的每个元素，然后随机一个索引出来，让该元素与随机索引位置处的元素值进行交换（本节的重点）
        // codes = [12, 36, 28, 45, 99]
        Random r = new Random();
        for (int i = 0; i < codes.length; i++) {
            // 当前遍历的元素值：codes[i]
            // 随机一个索引位置出来：codes[index]
            int index = r.nextInt(codes.length);

            // 定义一个临时变量存储index位置处的值
            int temp = codes[index];
            codes[index] = codes[i];
            codes[i] = temp;
        }

        // 4、遍历数组元素输出就是随机排名的结果
        for (int i = 0; i < codes.length; i++) {
            System.out.print(codes[i] + "\t");
        }
    }
}

数组排序

public class Test5 {
    public static void main(String[] args) {
        // 1、定义一个数组，存储一些数据啊
        int[] arr = {5, 2, 3, 1};
        //           0  1  2  3

        // 2、定义一个循环控制比较的轮数
        for (int i = 0; i < arr.length - 1; i++) {
            // i == 0  比较的次数 3  j = 0 1 2
            // i == 1  比较的次数 2  j = 0 1
            // i == 2  比较的次数 1  j = 0
            // 3、定义一个循环控制每轮比较的次数，占位
            for (int j = 0; j < arr.length - i - 1; j++) {
                // 判断j当前位置的元素值 是否 大于后一个位置 若较大 则交换
                if(arr[j] > arr[j+1]) {
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }

        // 遍历数组内容输出
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

---

4、数组的内存图

4.1 内存概述

​ 内存是计算机中的重要原件，临时存储区域，作用是运行程序。

​ 我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。

​ 必须放进内存中才能运行，运行完毕后会清空内存。

​ Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

4.2 java中的内存分配

• 目前我们只需要记住两个内存，分别是：栈内存和堆内存

区域名称	作用
寄存器	给CPU使用，和我们开发无关。
本地方法栈	JVM在使用操作系统功能的时候使用，和我们开发无关。
方法区	存储可以运行的class文件。
堆内存	存储对象或者数组，new来创建的，都存储在堆内存。
方法栈	方法运行时使用的内存，比如main方法运行，进入方法栈中执行。

java内存分配、数组内存图

两个数组变量指向同一个数组对象

---

5、数组使用的常见问题

5.1 索引越界异常

出现原因

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr[3]);
    }
}

数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。

程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

• 解决方案

  将错误的索引修改为正确的索引范围即可！

5.2 空指针异常

出现原因

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

        //把null赋值给数组
        arr = null;
        System.out.println(arr[0]);
    }
}

arr = null 这行代码，意味着变量arr将不会再保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

• 解决方案

  给数组一个真正的堆内存空间引用即可！

---

6、Debug工具的使用

Debug工具

IDEA自带的断点调试(排错)工具，可以控制代码从断点开始一行一行的执行，然后详细观看程序执行的情况。

---