数组介绍
数组是一种容器,可以存储同种数据类型的多个值
double[] arr1 = {11.1, 22.2, 33};
System.out.println(arr1[2]); // 33.0
int[] arr2 = {10, 20, 'a'};
System.out.println(arr2[2]); // 97
数组的定义格式
数据类型[] 数组名;
int[] arr;
数据类型 数组名[];
int arr[];
这种定义格式定义出来的只是数组类型的变量而已,此时容器还没有被真正的创建
数组的静态初始化
初始化:在内存中,为数组容器开辟空间,并将数组存入空间的过程
静态初始化完整格式:
数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3..};
int[] arr = new int[]{11,22,33,44,55};
静态初始化简化格式:
数据类型[] 数组名 = {元素1, 元素2, 元素3..};
int[] arr = {11,22,33,44,55};
打印数组名将得到数组的十六进制内存地址
[I@233ac41
@ : 分隔符
[ : 代表当前空间是数组类型, 几个中括号就是几维数组
I : 当前数组是int类型
233ac41 : 十六进制内存地址
数组的元素访问
格式:数组名[索引];
索引介绍:(角标,下标)数组中,每一个空间所对应的编号,编号从0开始逐个+1增长
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55};
System.out.println(arr); // 数组的地址值
// 元素访问: 数组中的22元素取出来进行打印
System.out.println(arr[1]);
// 元素访问: 数组中33元素, 修改为66
arr[2] = 66;
System.out.println(arr[2]);
// 元素访问: 判断数组中的第一个元素, 是奇数还是偶数
if (arr[0] % 2 == 0) {
System.out.println(arr[0] + "是一个偶数");
} else {
System.out.println(arr[0] + "是一个奇数");
}
// 元素访问: 根据数组中第二个元素, 决定在控制台打印多少次HelloWorld
for(int i = 1; i <= arr[1]; i++){
System.out.println("HelloWorld");
}
}
数组的遍历操作
介绍:将数组中的[每一个]元素取出进行操作
场景:如果要实现的需求需要操作到数组中的每一个数据,就需要遍历数组
/*
数组的遍历操作: 将数组中每一个元素, 取出来进行操作
----------------------------------------------
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]);
}
弊端: 循环次数写死了(硬编码)
解决: 每一个数组中, 都存在一个属性 length
使用方式: 数组名.length ---> 动态的获取到数组的长度
长度: 数组中的元素个数
----------------------------------------------
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
*/
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55};
// 遍历数组快捷键: 数组名.fori + 回车
for (int i = 0; i < arr.length; i++) {
// i : 索引
// arr[i] : 数组中的元素
System.out.println(arr[i]);
}
}
需求: 已知数组元素为 {11,22,33,44,55}
1. 求出数组最大值
2. 求出数组最小值
3. 求出数组的总和
4. 计算数组的平均值
5. 将最大值, 最小值, 总和, 平均值打印在控制台
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55};
// 1. 求出数组最大值
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
// 2. 求出数组最小值
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] < min) {
min = arr[i];
}
}
// 3. 求出数组的总和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
// 4. 计算数组的平均值
double avg = sum / (arr.length * 1.0);
// 5. 将最大值, 最小值, 总和, 平均值打印在控制台
System.out.println("最大值为:" + max);
System.out.println("最小值为:" + min);
System.out.println("总和为:" + sum);
System.out.println("平均值为:" + avg);
}
数组的动态初始化
介绍:在创建数组的时候,只需要指定长度,系统就会分配默认初始化值
格式:数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[3];
默认值的分类:
整数 : 0
小数 : 0.0
布尔 : false
字符 : '\u0000' ---> Unicode字符 ---> 常见的体现是空白字符
引用数据类型 : null
----------------------------------------
引用数据类型: 数组, 类, 接口
两种初始化的对比:
区别:
1. 动态初始化:手动指定长度,系统分配默认值
2. 静态初始化:手动指定元素,由系统计算出数组的长度
场景:
1.动态初始化:只知道要存储几个元素,但是明确具体数值
需求1:键盘录入5个整数,求出最大值
需求2:产生10个1~100之间的随机数,求出最小值
数组的内存图
Java内存分配介绍
数组的常见问题
数组索引越界异常:ArrayIndexOutOfBoundsException:
原因:访问了不存在的索引
空指针异常:NullPointerException:
原因:当引用数据类型的变量记录到null之后,代表跟堆内存的链接被切断了,这时候还要去访问堆内存的数据就会出现空指针异常
二维数组的介绍
介绍:二维数组也是一个容器,容器中存储的都是一维数组
场景:发现要操作的数组有多个,这多个数组也属于一个整体
某公司4个季度的销售额:
int[][] arr = {
{11,22,33},
{11,55,22},
{22,33,44},
{77,11,33}
}
二维数组静态初始化
完整格式:
数据类型[][] 数组名 = new 数据类型[][] {
{一维数组1},
{一维数组2}
};
int[][] arr = new int[][]{
{11,22,33},
{44,55,66}
};
简化格式:
数据类型[][] 数组名 = {
{一维数组1},
{一维数组2}
};
int[][] arr = {
{11,22,33},
{44,55,66}
};
二维数组的元素访问:
格式 : 数组名[m索引][n索引];
m索引 : 要访问哪一个一维数组
n索引 : 访问一维数组中的哪一个元素
System.out.println(arr[0][1]);
二维数组的遍历操作
思路:
遍历二维数组,获取到每一个一维数组
继续遍历一维数组,获得具体的元素
int[][] arr = {
{11,22,33},
{44,55,66}
};
// 遍历二维数组, 获取到每一个一维数组
for(int i = 0; i < arr.length; i++){
// arr[i] : 代表每一个一维数组
// 继续遍历一维数组, 获取具体的元素
for(int j = 0; j < arr[i].length; j++){
System.out.println(arr[i][j]);
}
}
二维数组动态初始化
格式
数据类型[][] 数组名 = new 数据类型[m][n];
m : 指定这个二维数组, 可以存储多少个一维数组
n : 指定每一个一维数组中, 可以存储多少个元素
int[][] arr = new int[2][3];
这个二维数组, 可以存储2个一维数组, 每一个一维数组中可以存储3个元素