十三、数组
1.数组概述
数字就是用来存储一批同种类型数据的内存区域（可以理解为容器）。
内存
10
20
60
80
90
例子：
int [] arr = {20, 10, 80, 60, 90};
String[] names = {"牛二", "西门", "全蛋"};场景：假如用变量存储这些名字，然后完成随机点名功能，怎么实现？存在有什么问题？
// 使用数组完成
String[] names = {"章鱼哥", "海绵宝宝", "派大星"};关于数组需要学会什么？
- 怎么定义数组存储数据？
- 怎么操作数组元素？
- 怎么解决实际问题？
- 数组内存原理？
- 数组使用的注意点？
2.数组的定义
a.静态初始化数组
Ⅰ.定义数组
定义数组的时候直接给数组赋值。
格式：
// 完整格式
数据类型[] 数组名 = 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};
int[] ages = {12, 24, 36};基本原理：数组变量名存储的是数组在内存中的地址，数组是引用类型。
int[] ages = {12, 24, 36};
System.out.println(ages);
// ages I@4c873330
// | |
// int 4c873330 是在内存中的十六进制地址从左往右赋值。ages记录的是数组的第一个地址。
内存
ages
array
12
24
36
总结：
- 数组的静态初始化的写法和特点什么样的？
数据类型[] 数组名 = {元素1, 元素2, 元素3};
int[] ages = {12, 24, 36, 48, 60};
double[] scores = {89.9, 99.5, 59.5};
// 完整格式
数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3};
int[] ages = new int[]{12, 24, 36, 48, 60};- 数组是属于什么类型，数组变量名中存储的是什么？
- 引用数据类型，存储的数组在内存中的地址信息。
Ⅱ.访问数组
数组名称
// 取值
System.out.println(arr[0]);
// 赋值
arr[2] = 100;
System.out.println(arr[2]);数组的长度属性：length
// 获取数组的长度(数组元素的个数)
System.out.println(arr.length);问题：数组的最大索引可以怎么表示？
// 前提：元素个数大于0
数组名.length - 1Ⅲ.注意事项
"数组类型[] 数组名"也可以写成"数据类型 数组名[]"。
int[] arr = {30, 40};
int arr[] = {30, 40};- 什么类型的数组存放什么类型的数据，否则报错。
// 错误示例
int[] arr = new int[]{30, 40, "派大星"};- 数组一旦定义出来，程序执行的过程中，长度、类型就固定了。
b.动态初始化数组
Ⅰ.定义数组
定义数组的时候只确定元素的类型和数组的长度，之后再存入具体数据。
数组的动态初始化格式：
数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[3];
// 后赋值
arr[0] = 10;
System.out.println(arr[0]);
// 目标：学会动态初始化数组的定义和使用
double[] scores = new double[3];
// 默认 {0.0, 0.0, 0.0}
// 赋值
scores[0] = 99.5;
System.out.println(scores[0]);
System.out.println(scores[1]);
// 默认 null
String[] names = new String[90];
names[0] = "章鱼哥";
names[1] = "海绵宝爸";
System.out.println(names[0]);
System.out.println(names[1]);
System.out.println(names[2]);Ⅱ.总结
- 动态初始化的写法是什么样的？
数据类型[] 数组名 = new 数据类型[长度];
int[] ages = new int[4]- 两种数组定义时的特点和场景有什么区别？
- 当前已经知道存入的元素值，用静态初始化。
- 当前还不知道要存入哪些数据，用动态初始化。
Ⅲ.动态初始化数组的元素默认值
元素默认值规则：
数据类型 | 明细 | 默认值 |
基本类型 | byte、short、char、int、long | 0 |
float、double | 0.0 | |
boolean | false | |
引用类型 | 类、接口、数组、String | null |
两种初始化的使用场景总结、注意事项说明：
- 动态初始化：只指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景。
- 静态初始化：开始就存入元素值，适合一开始就能确定元素值的业务场景。
- 两种格式的写法是独立的，不可以混用。
3.数组的遍历
- 遍历：就是一个一个数据的访问。
- 为什么要遍历？搜索、数据统计等等都需要用到遍历。
int[] ages = {20, 30, 40, 50};
// 方式一 快捷键 ages.fori
for (int i =0; i< ages.length; i++) {
System.out.println(ages[i]);
}
// 方式二 快捷键 ages.for
for (int age : ages) {
System.out.println(age);
}4.数组的案例
a.数组元素求和
需求：某部门5名员工的销售额分别是：16、26、36、6、100，请计算出他们部门的总销售额。
// 定义销售额
int[] moneys = {16, 26, 36, 6, 100};
// 定义总销售额
int count = 0;
// 遍历累加 方式一
for (int money : moneys) {
count += money;
}
System.out.println(count);
// 遍历累加 方式二
for (int i; i < moneys.length; i++) {
count += mongos[i];
}b.数组求最高值
分析：
- 将颜值数据拿到程序中去，用数组装起来。
int[] faceScores = {15, 9000, 10000, 20000, 9500, -5};- 定义一个变量用于记录最大值，这个变量建议默认存储第一个元素作为参照。
int max = faceScores[0];- 遍历数组的元素，如果该元素大于变量存储的元素，则替换变量存储的值为该元素。
for (int i = 1; i < faceScores.length, i++) {
if (faceScores[i] > max) {
// 替换
max = faceScores[i];
}
}- 完整代码
// 定义颜值数组
int[] faceScores = {15, 9000, 10000, 20000, 9500, -5};
// 定义最大值
int max = faceScores[0];
for (int faceScore : faceScores) {
if (max < faceScore) {
max = faceScore;
}
}
System.out.println("颜值最高为:" + max);c.猜数字游戏
开发一个幸运小游戏，游戏规则如下：游戏后台随机生成1-20之间的五个数（无所谓是否重复），然后让大家来猜数字：
- 未猜中提示：”未猜中“，并继续猜测。
- 猜中提示：”运气不错，猜中了“，并输出该数据第一个出现的位置，且输出全部5个数据，最终结束本游戏。
分析：
- 随机生成5个1-20之间的数据使用数组存储起来。
- 定义一个死循环，输入数据猜测，遍历数组，判断数据是否在数组中，如果在，进行对应提示并结束死循环，如果没有猜中，提示绩效猜测直到猜中为止。
// 开发一个幸运小游戏，游戏规则如下：游戏后台随机生成1-20之间的五个数（无所谓是否重复），然后让大家来猜数字：
//- 未猜中提示：”未猜中“，并继续猜测。
//- 猜中提示：”运气不错，猜中了“，并输出该数据第一个出现的位置，且输出全部5个数据，最终结束本游戏。
// 1.定义动态初始化的数组存储5个随机嗯1-20之间的数据
int[] luckNumbers = new int[5];
// 2.动态的生成5个1-20之间的随机数并存入到数组中去
Random rd = new Random();
for (int i = 0; i < luckNumbers.length; i++) {
luckNumbers[i] = rd.nextInt(1, 20);
}
// 3.获取键盘扫描器对象
Scanner sc = new Scanner(System.in);
// 4.死循环开始游戏
// 设置标号 OUT
OUT:
while (true) {
System.out.println("请你输入一个1-20的整数进行猜测：");
// 输入数字
int inputNumber = sc.nextInt();
// 遍历幸运数组
for (int luckNumber : luckNumbers) {
// 判断是否猜中
if (luckNumber == inputNumber) {
System.out.println("运气不错，猜中了， 您猜中的数据是：" + luckNumber);
// 通过break OUT 结束整个循环
break OUT;
}
}
// 猜错
System.out.println("未猜中， 请继续猜数字！");
}
// 所有幸运数字
for (int luckNumber : luckNumbers) {
System.out.print(luckNumber + "\t");
}d.随机排名
需求：某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名进行汇报。
请先依次录入5名员工的工号，然后展出一组随机的排名顺序。
22 33 35 13 88 -> 13 35 88 33 22分析：
- 在程序中录入5名员工的工号存储起来 -> 使用数组。
- 依次遍历数组中的每个元素，随机一个索引数据，让当前元素与该索引位置处的元素进行交换。
package com.javase.arraycase;
import java.util.Random;
import java.util.Scanner;
public class ArrayCaseDemo4 {
public static void main(String[] args) {
// 需求：某公司开发部5名开发人员，要进行项目进展汇 报演讲，现在采取随机排名进行汇报。
// 请先依次录入5名员工的工号，然后展出一组随机的排名顺序。
// 1.定义动态数组
int[] numbers = new int[5];
// 2.循环输入5次员工工号 存入数组中
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 5; i++) {
System.out.println("请您输入第" + (i+1) + "位的员工工号：");
int number = sc.nextInt();
numbers[i] = number;
}
System.out.println(numbers[0]);
// 3.随机排序
Random r = new Random();
for (int i = 0; i < numbers.length; i++) {
// 定义随机索引
int index = r.nextInt(0, 5);
// 定义交换临时中间变量
int temp;
temp = numbers[i];
numbers[i] = numbers[index];
numbers[index] = temp;
}
// 4.展出一组随机的排名顺序
System.out.println("随机排名：");
for (int number : numbers) {
System.out.print(number + "\t");
}
}
}总结：
- 如何实现随机排名的？
- 定义一个动态初始化的数组用于录入数据。
- 遍历数组中的每个元素，每次随机一个索引值，让当前元素与该索引位置处的元素进行交换。
e.数组排序
就是对数组中的元素，进行升序（由小到大）或者降序（由大到小）的操作。
数组排序的技术
- 冒泡排序
- 选择排序
- 快速排序
- 插入排序
- …
数据搜索相关的技术
- 二分搜索
- 分开查找
- 哈希表查找
- …
Ⅰ.冒泡排序
冒泡排序的思想s
- 每次从数组中找出最大值放在数组的后面去。
实现冒泡排序的关键步骤分析
- 确定总共需要做几轮：数组的长度-1 （四个元素找出三个最大值）。
package com.javase.arraysort;
public class ArraySortDemo1 {
public static void main(String[] args) {
// 1.定义一个数组，存储一些数据
// 索引 0 1 2 3
int[] arr = {5, 2, 3, 1};
// 2.定义一个循环控制比较的论数
for (int i = 0; i < arr.length - 1; i++) {
// 如果一轮循环完成之后 没有发生交换 说明数组本身就有序 后续循环无需再做
boolean swapped = false;
for (int j = 0; j < arr.length - i -1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
swapped = true;
}
}
// 如果没有发生交换 跳出循环
if (!swapped) {
break;
}
}
for (int i : arr) {
System.out.println(i);
}
}
}总结
- 冒泡排序的思想？
- 从头开始两两比较，把较大的元素与较小的元素进行交换。
- 每轮把当前最大的一个元素存入到数组当前的末尾。
- 冒泡排序的实现步骤？
- 定义一个外部循环控制总共需要冒几轮（数组的长度-1）
- 定义一个内部循环，控制每轮依次往后比较几个位置（数组长度-i-1）。
- 如果当前位置的元素大于后一个位置的元素值，两者交换。
5.数组的内存图
a.Java内存分配、数组内存图
Ⅰ.Java内存分配介绍
- 栈：方法运行时所进入的内存，变量也是在这里。
- 堆：new出来的东西会在这块内存中开辟空间并产生地址。
- 方法区：字节码文件（HelloWorld.class）加载时进入的内存。
- 本地方法栈
- 寄存器
package com.javase.ram;
public class RamDemo1 {
public static void main(String[] args) {
int a = 12;
System.out.println(a);
int[] arr = {11, 22, 33};
System.out.println(arr);
arr[0] = 44;
arr[1] = 55;
arr[2] = 66;
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
方法区
栈内存
Test.class
方法区main
栈内存main
a
10
栈内存arr
3fee733d
堆内存
堆内存arr
55
66
44-3fee733d
b.两个变量指向同一个数组
package com.javase.ram;
public class RamDemo2 {
public static void main(String[] args) {
// 目标：两个变量指向同一个数组
int[] arr1 = {11, 22, 33};
// 把数字arr1变量赋值给int类型的数组变量arr2
int[] arr2 = arr1;
System.out.println(arr1);
System.out.println(arr2);
arr2[1] = 99;
System.out.println(arr1[1]);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}
方法区
栈内存
Test.class
方法区main
栈内存main
栈内存arr1
3fee733d
栈内存arr2
堆内存
堆内存arr
55
66
44-3fee733d
6.数组使用的常见问题
- 问题一：如果访问的元素位置超过最大索引，执行时会出现
ArrayIndexOutOfBoundsException（数组索引越界异常）。
int[] arr = new int[]{11, 22, 33};
System.out.println(arr[2]);
// 出现异常
// System.out.println(arr[3]);- 问题二：如果数组变量中没有存储数组的地址，而是null，在访问数组信息时会出现
NullPointerException（空指针异常）。
int[] arr = new int[]{11, 22, 33};
arr = null;
// 出现异常
// System.out.println(arr.length);7.Debug工具的使用
IDEA自带的断点调试（排错）工具，可以控制代码从断点开始一行一行的执行，然后详细观看程序执行的情况。
DEBUG工具基本使用步骤：
- 在需要控制的代码行左侧，点击一下，形成断电。
- 选择使用Debug方式启动程序，启动后程序会在断点暂停。
- 控制代码一行一行的往下执行。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
