Java数组
- 数组就是用来存储一批同种类型数据的内存区域（可以理解为容器）
数组的定义
静态初始化数组
-
定义数组的时候直接给数组赋值
-
静态初始化格式：
// 完整格式 数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3……}; double[] scores = new double[]{90.0, 85.5, 72.6, 66.1}; String[] items = new String[]{'台球', '铅球', '足球', '排球', '羽球'};// 简化格式 数据类型[] 数组名 = {元素1, 元素2, 元素3……}; int[] age = {12, 24, 36};
动态初始化数组
-
定义数组的时候只确定元素的类型和数组的长度，之后再存入具体的数据
-
动态初始化格式
数据类型[] 数组名 = new 数据类型[长度]; int[] array = new int[3]; //后赋值 arr[0] = 10; System.out.println(arr[0]); // 10
数组的访问
-
数组名称[索引]
数组的索引从0开始
-
数组的长度属性：length
数组名.length // 获取数组的长度
-
数组的最大索引表示：
数组名.length - 1 // 前提：数组的元素个数大于1
元素默认规则
| 数据类型 | 明细 | 默认值 |
|---|---|---|
| 基本类型 | byte，short，char，int，long | 0 |
| float，double | 0.0 | |
| boolean | false | |
| 引用类型 | 类，接口，数组，String | null |
数组的遍历
-
遍历就是对所有数据按照一定规则一个一个的访问
-
如何遍历数组的元素：关键在于数组长度作为循环条件，初始化语句决定着从第几个元素开始遍历，步进语句决定着循环的元素间隔，灵活使用可以实现从某个元素开始遍历，每三个遍历一次等操作
int[] ages = {20, 30, 40, 50}; for (int i = 0; i < ages.length; i++) { System.out.println(ages[i]); }
元素交换
-
创建中间变量进行交换
void swapr(int &a, int &b) { int temp = a; a = b; b = a; } -
使用异或运算特性进行交换
void swapr(int &a, int &b) { a ^= b; b ^= a; a ^= b; }
数组的内存图
- 数组的基本原理：在堆内存你中为数组开辟一片连续的内存空间且分配地址，并划分成多个相等的空间用于装载元素，数组变量名通过获取地址实现对内存块中元素的交互
- 数组变量名中存储的是数组在内存中的地址，即打印数组变量名会得到该数组的地址，首字母为数组数据类型首字母，其后的数字为十六进制数表示的地址。数组是引用类型
Java内存分配介绍
- 栈：方法运行时所进入的内存；变量也在此
- 堆：new出的内容（对象）会在此内存开辟空间并产生地址
- 方法区：字节码文件加载时进入的内存
- 本地方法栈
- 寄存器
例子：
image.png
两个数组变量指向同一个数组对象，对数组对象的修改会引起两个数组变量同时发生变化
image.png
其他注意事项
- “数据类型[] 数组名” 也可以写成 “数据类型 数组名[]”
- Java是强类型语言，严格要求什么类型的数组存放什么类型的数据，否则报错
- 数组一旦被定义出来，程序的执行过程中，长度和类型就固定了，就不可以更改
-
动态静态的含义在于数组元素是否后期动态装载：
-
当前已经知道存入的元素值，用静态初始化
-
当前还不清楚要存入哪些数据，用动态初始化
-
- 数组索引越界异常（ArrayIndexOutOfBoundsException）：访问的元素位置超过最大索引
- 空指针异常（NullPointerException）：数组变量中没有存储数组的地址，而是null
数组常见应用
常见应用:
- 元素求和
- 求最值
- 猜数字
- 随机排名
- 冒泡排序
package com.java.test;
/**
* 数组的常见应用：
* 1. 元素求和
* 2. 求最值
* 3. 猜数字游戏
* 4. 随机排名
* 5. 数组排序
*/
public class ArrayCase {
public static void main(String[] args) {
//1. 元素求和
//某部门5名员工的销售额分别是：16，26，36，6，100，请计算出他们部门的总销售额
int[] arr1 = new int[]{16, 26, 36, 6, 100};
for (int i = 0; i < arr1.length; i++) {
arr1[i] += arr1[i];
}
System.out.println("部门的总销售额：" + arr1[arr1.length - 1]);
System.out.println("------------------------------------------");
//2. 求最值
//给定一组数据求最值
int[] arr2 = new int[]{15, 36, 72, 85, 61, -2, 99};
int max = arr2[0];
int min = arr2[0];
for (int i = 1; i < arr2.length; i++) {
if (arr2[i] > max) {
max = arr2[i];
}
if (arr2[i] < min) {
min = arr2[i];
}
}
System.out.println("最大值：" + max + '\n' + "最小值：" + min);
System.out.println("------------------------------------------");
//3. 猜数字游戏
//游戏规则：生成[1-20]之间的5个数（可重复），未猜中提示“未命中”并继续猜测
// 猜中提示猜中并输出该数第一次出现的位置，然后输出全部5个数据，结束游戏
Random r = new Random();
Scanner sc = new Scanner(System.in);
int[] arr3 = new int[5];
for (int i = 0; i < 5; i++) {
arr3[i] = r.nextInt(20) + 1;
}
demo:
//创建一个break的结束标签demo
while (true) {
System.out.println("请合法输入位于[1,20]的任意数进行猜测！");
int num = sc.nextInt();
for (int i = 0; i < arr3.length; i++) {
if (num == arr3[i]) {
System.out.println("您猜对了！");
System.out.println("您猜对的数处于数组中的第" + (i + 1) + "个");
for (int m = 0; m < arr3.length; m++) {
System.out.print(arr3[m] + "\t");
System.out.println();
}
break demo;
}
}
System.out.println("您猜测的数据不在数组当中，请重新猜测！");
System.out.println("--------------------------------------");
}
System.out.println("--------------------------------------");
//4. 随机排名
//有五个人需要进行演讲，请打乱他们的顺序，利用随机保证公平性
int[] arr4 = new int[5];
Scanner in = new Scanner(System.in);
Random rand = new Random();
for (int i = 0; i < arr4.length; i++) {
System.out.println("请输入第" + (i + 1) + "位演讲者的编号：");
arr4[i] = in.nextInt();
}
for (int i = 0; i < arr4.length; i++) {
int index = rand.nextInt(arr4.length);
int temp = arr4[index];
arr4[index] = arr4[i];
arr4[i] = temp;
}
for (int i = 0; i < arr4.length; i++) {
System.out.print(arr4[i] + "\t");
}
System.out.println("--------------------------------------");
//5. 数组排序
//给定一组数据进行升序排序，算法指定：冒泡排序
int[] arr5 = new int[]{5, 2, 3, 1};
// 0 1 2 3
//定义一个循环控制比较的轮数
for (int i = 0; i < arr5.length - 1; i++) {
/*
i == 1 比较的次数 3 j = 0 1 2
i == 2 比较的次数 2 j = 0 1
i == 3 比较的次数 1 j = 0
*/
//定义一个循环控制每轮比较的次数，占位
for (int j = 0; j < arr5.length - i; j++) {
// 判断当前位置的元素值，是否大于后一个位置，若较大，则交换
if (arr5[j] > arr5[j + 1]) {
int temp = arr5[j + 1];
arr5[j + 1] = arr5[j];
arr5[j] = temp;
}
}
}
}
}
数组排序
- 数组排序的技术
- 冒泡排序
- 选择排序
- 快速排序
- 插入排序
- ……
- 数组搜索相关技术
- 二分搜索
- 分块查找
- 哈希表查找
- ……
冒泡排序（面试热点）
-
思想：
- 从头开始两两比较，把较大的元素与较小的元素进行交换
- 每轮把当前最大的一个元素存入到数组当前的末尾
-
实现冒泡排序的关键步骤分析：
- 确定排序总共需要几轮：数组的长度 - 1
- 每轮比较几次：数组的长度 - i（随着轮数i增多而递减）
-
冒泡排序的实现步骤
-
定义一个外部循环控制总共需要冒几轮(数组的长度 - 1)
-
定义一个内部循环，控制每轮依次往后比较几个位置（数组的长度 - i）
注意 ，如果从0开始循环，此处的上界应该是：数组的长度 - i - 1
-
如果当前位置的元素值大于后一个位置的元素值，两者交换
-
-
例子：
package com.java.test; import java.util.Scanner; public class BubbleSort { public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.println("请输入参加冒泡排序的整数的个数："); int sum = in.nextInt(); System.out.println("请输入这" + sum + "个数:"); int[] arr = new int[sum]; for (int i = 0; i < arr.length; i++) { arr[i] = in.nextInt(); } for (int i = 0; i < arr.length - 1; i++) { for (int j = 0; j < arr.length - i - 1; j++) { if (arr[j] > arr[j + 1]) { arr[j] ^= arr[j + 1]; arr[j + 1] ^= arr[j]; arr[j] ^= arr[j + 1]; } } } System.out.println("排序后数组遍历结果"); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + "\t"); } } }
网友评论