数组就是用来存储一批同种类型数据的内存区域（可以理解成容器）。
数组适合做一批同种类型数据的存储。
Java-数组的定义
静态初始化数组
数组的访问
数组的几个注意事项
动态初始化数组
动态初始化数组的元素默认值
Java-数组的定义-静态初始化数组
定义数组的时候直接给数组赋值
静态初始化数组的格式：
// 完整写法
double [] scores = new double[] {75.5,65.5,90.0,100};
int [] ages = new int[] {26,22,23,25};
// 简化写法
double [] scores = {75.5,65.5,90.0,100};
int [] ages = new int[] {26,22,23,25};
数组变量名中存储的是数组在内存中的地址，数组是引用类型
Java-数组的定义-静态初始化数组-数组的访问
数组的访问：数组名称[ 索引 ]
// 取值 System.out.println(scores[0]); // 赋值 scores[2] = 65.5; System.out.println(scores[2]);
数组的长度属性：length
System.out.println(scores.length);
数组的最大索引怎么表示：数组名.length -1 //前提元素个数大于0
System.out.println(ages.length - 1);
Java-数组的定义-静态初始化数组-数组的几个注意事项
"数据类型[ ] 数组名" 也可以写成 "数据类型 数组名 [ ]"
// 1. "数据类型[ ] 数组名" 也可以写成 "数据类型 数组名 [ ]"
int [] ages = {26,38,76};
int ages1 [] = {36,35,34};
什么类型的数组存放什么类型的数据，否则报错
// 2. 什么类型的数组存放什么类型的数据，否则报错
String [] names = {"张三" , "李四" , 23}; // 错误
数组一旦定义出来，程序执行的过程中，长度，类型就固定了
// 3. 数组一旦定义出来，程序执行的过程中，长度，类型就固定了
int [] ages2 = {11,22,33};
System.out.println(ages2[3]); // 报错 长度固定是3了不能访问第4个元素
Java-数组的定义-动态初始化数组
定义数组的时候只确定元素的类型和数组的长度，之后再存入具体数据
数组的动态初始化格式：
// 数据类型[] 数组名 = new 数据类型[长度]; double [] scores = new double[3]; // 后赋值 scores[0] = 15; System.out.println(scores[0]);
两种数组定义时的特点和场景有什么区别：
当前已经知道存入的元素值，用静态初始化。
当前还不清楚要存入哪些数据，用动态初始化。
Java-数组的定义-动态初始化数组-动态初始化数组的元素默认值
元素的默认值规则：
| 数据类型 | 明细 | 默认值 |
|---|---|---|
| 基本类型 | byte、short、char、int、long | 0 |
| 基本类型 | float、double | 0.0 |
| 基本类型 | boolean | false |
| 引用类型 | 类、接口、数组、String | null |
// 1. 整型数组的元素默认值都是0 int [] arr = new int[10]; System.out.println(arr[0]); // 0 System.out.println(arr[3]); // 0 // 2. 字符数组的元素默认值也是0 char[] chars = new char[100]; System.out.println((int)chars[8]); // 0 System.out.println((int)chars[10]); // 0 // 3. 浮点型数组的元素默认值是0.0 double[] scores = new double[95]; System.out.println(scores[0]); // 0.0 System.out.println(scores[15]); // 0.0 // 4. 布尔类型的数组 boolean[] booleans = new boolean[100]; System.out.println(booleans[0]); // false System.out.println(booleans[99]); // false // 5. 引用类型的数组 String[] names = new String[90]; System.out.println(names[0]); // null System.out.println(names[89]); // null
两种初始化的使用场景总结、注意事项说明：
- 动态初始化：只指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景静态初始化：开始就存入元素值，适合一开始就能确定元素值的业务场景两种格式的写法是独立的，不可以混用
Java-数组的遍历
数组遍历介绍：
- 遍历：就是一个一个数据的访问搜索、数据统计等等都需要用到遍历
int [] arr = {26,27,28,29,30};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
Java-数组的案例
数组遍历-求和：需求：某部门5名员工的销售额分别是：15、28、19、32、100，请计算出他们部门的总销售额。
int [] money = {15,18,19,32,100};
int sum = 0;
for (int i = 0; i < money.length; i++) {
sum += money[i];
}
System.out.println("数组的元素和是：" + sum);
数组求最值：
// 1. 定义一个静态初始化的数组，存储一批颜值
int[] faceScore = {15,9000,10000,20000,9500,-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);
猜数字游戏：需求：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++) {
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");
}
随机排名：键盘录入一组工号，最终要随机输出一组出来作为排名
// 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;
}12
// 3. 遍历数组中的每个元素，然后随机一个索引出来，让该元素与随机索引位置处的元素值进行交换
Random r = new Random();
for (int i = 0; i < codes.length; i++) {
// 当前遍历的元素值：codes[i]
// 随机一个索引位置出来
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");
}
数组的排序：就是对数组中的元素，进行升序(由小到大)或者降序（由大到小）的操作。
数组排序的技术：冒泡排序、选择排序、快速排序、插入排序
数组搜索相关的技术：二分搜索、分块查找、哈希表查找
// 1. 定义一个数组，存储一些数据
int[] arr = {6,5,9,3};
// 2. 定义一个循环控制比较的轮数
for (int i = 0; i < arr.length -1 ; i++) {
// 定义一个循环控制每轮比较的次数，占位
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");
}
Java-数组使用常见问题
如果访问的元素位置超过最大索引，执行时会出现Array Index Out Of Bounds Exception(数组索引越界异常)
如果数组变量中没有存储数组的地址，而是null, 在访问数组信息时会出现Null Pointer Exception(空指针异常)
