day5
1.数组介绍
数组:存储多种数据类型的多个数。
int [ ] arr={80,76,65}
2.数组定义格式和静态初始化
静态初始化:在内存中,为数组容器开辟空间,并将元素存入空间
定义格式:
01完整格式:
数组类型【】 数组名 = new 数据类型【】{元素1,元素2,元素3…};
02简化格式:
数组类型【】 数组名 = {元素1,元素2,元素3…};
打印数组名:
public static void main(String[] args) {
//创建一个数组
double [] arr1 =new double[]{11.1,11.2,11.3};
//元素访问:数组名【索引】即arr1[1]
System.out.println(arr1[1]);
}
—数组在内存中的十六进制地址值
@ :分隔符
【 :当前空间是一个数组类型,一堆数组
[D@16b98e56
注:打印数组名:运行后得到数组在内存中十六进制地址
3.数组元素访问
格式:数组名【索引】
索引:每一个数对应的编号,从0开始,逐1增加
public static void main(String[] args) {
//创建一个数组
double [] arr1 =new double[]{11.1,11.2,11.3};
//元素访问:数组名【索引】即arr1[1]
System.out.println(arr1[1]);
}
4.数组遍历操作
定义:将元素取出来(打印,求和,求最大值、最小值、平均值)
01打印所有元素
public static void main(String[] args) {
double arr[] ={11.1,22.2};
System.out.println(arr[0]);
System.out.println(arr[1]);
}
02求偶数和
需求:已知数组元素为 {11,22,33,44,55} 请将数组中偶数元素取出并求和,最后打印求和结果
public static void main(String[] args) {
/*
分析:
1.静态初始化数组
2.定义求和变量
3.遍历数组取出每一个元素
4.判断当前元素是否是偶数,是的话跟求和变量做累加操作
5.打印求和变量
*/
//创建数组
int arr[]={11,22,33,44,55};
//定义求和变量
int sum =0;
//遍历循环
for (int i = 0; i < arr.length; i++) {
//条件判断
if (arr[i]%2==0){
//累计求和
sum+=arr[i];
}
}
//打印求和变量
System.out.println(sum);
}
03求最大值
需求: 从数组中找最大值
分析:
public static void main(String[] args) {
/*
分析: 1.假设数组中的第一个元素, 就是最大值
2.遍历数组, 获取剩余的每一个元素, 准备进行比较(索引从1开始)
3.在遍历的过程中, 逐个进行比较
4.如果找到了更大的, 就让max变量, 记录更大的元素
5.在遍历结束后, 打印max所记录的值.
*/
int arr[] ={11,98,34,45,105};
int max=arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i]>max){
max=arr[i];
}
}
System.out.println
(max);
}
值为:"+sum/arr.length);
}
04.打乱一维数组数组:
需求:已知数组内部元素为 1 ~ 9 请将数组中元素随机打乱,随后遍历打印数组
分析:
1.准备 Random 产生随机数
2.循环遍历数组, 从 0 号索引开始访问每一个位置上的元素
3.在循环中, 根据数组的长度产生随机数 – 表示随机索引位置
4.数组元素交换
5.遍历打印数组
public static void main(String[] args) {
//创建一个数组
int nums[]={1,2,3,4,5,6,7,8,9};
// 0 1 2 3 4 5 6 7 8
// i
// index
//产生随机数
Random r=new Random();
//遍历
for (int i = 0; i < nums.length ;i++) {
//定义一个变量接收随机数
int index = r.nextInt(nums.length);
//打乱数组
int temp=nums[i];
nums[i]= nums [index];
nums[index]=temp;
}
//循环遍历打印结果查看
for (int i = 0; i < nums.length; i++) {
System.out.println(nums[i]);
}
}
5.数组的动态初始化
手动指定长度, 由系统分配默认初始化值。
int[] arr = new int[3];
System.out.println(arr[0]); // 0
System.out.println(arr[1]); // 0
System.out.println(arr[2]); // 0
动态初始化的格式 :
*
数据类型[] 数组名 = new 数据类型[数组的长度];
如: double[] Arr = new double[5];
- 不同类型的默认初始化值
- 整数 : 0
- 小数 : 0.0
- 字符 : ‘\u0000’ 空白字符
- 布尔 : false
- 引用数据类型 : null
- 引用数据类型 :
- 类
- 数组
- 接口
问题: 两种初始化的区别?
-
动态初始化 : 手动指定[长度], 系统分配默认初始化值
-
静态初始化 : 手动指定 {元素} , 系统会自动计算出该数组的长度.
两种初始化的应用场景 :
- 静态初始化 : 如果要操作的数据, 已经非常明确了, 那就直接静态初始化
需求: 统计体重, 61,62,63,64,65,66,67
int[] arr = {61,62,63,64,65,66,67};
-
动态初始化 : 如果只明确元素个数, 不明确具体数值的时候
需求1: 键盘录入3个整数, 并存入数组
int[] arr = new int[3];需求2: 产生10个1-100之间的随机数, 并存入数组.
int[] arr = new int[10];
注意事项 :
- 动态初始化和静态初始化不能结合使用
int[] arr = new int[3]{1,2,3}; // 错误代码
6.数组的内存图
了解:
单个数组的内存图
两个数组指向相同内存图
java的内存分配:
- 方法区:字节码文件加载时
- 栈:方法运行的时候所加载的内存
- 堆:new出来的东西都进入堆内存,开辟空间所产生地址值,还有默认初始化值
- 本地方法栈
- 寄存器
7.数组常见问题:
数组索引越界
ArrayIndexOutOfBoundsExceptions:
原因 : 当访问了不存在的索引, 就会出现此异常
int[] arr = {11,22,33};
// arr = 0x0011;
空指针异常
NullPointerException :
原因 : 当一个引用数据类型的变量, 被赋值为null之后, 跟堆内存的地址指向就被切断了, 这时候还想访问堆内存数据
arr = null; System.out.println(arr[0]);
// 引发空指针异常
8.二维数组
存储一维数组。
9.二维数组静态初始化
完整格式:
数据类型【】【】数组名=new 数据类型【】【】{
{元素1, 元素2},
{元素3, 元素4}
};
如: int[][] arr = new int[][] {
{11,22},
{33,44}
};
简化格式:
数据类型【】【】数组名={
{元素1,元素2},
{元素3,元素4}
};
如: int[][] arr = {
{11,22},
{33,44}
};
- 二维数组的访问:
二维数组中, 存储的都是一维数组, 真正存储的是一维数组的 [地址值]
arr[0] ; 只能获取到一维数组的地址值
- 二维数组的元素访问格式:
- 数组名[索引A][索引·B]
- 索引A: 二维数组中的一维数组
- 索引B: 一维数组中的具体元素
10-二维数组遍历操作
思路 : 遍历二维数组, 先获取到里面的每一个一维数组, 随后再对一维数组进行遍历, 从而获取到具体的元素
int[][] arr = {
{11,22},
{33,44}
};
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]);
}
}
12.二维数组动态初始化
格式 :
数据类型[][] 数组名 = new 数据类型[m][n];
m : 当前二维数组可以存储多少个一维数组
n : 每一个一维数组中可以存储多少个元素
int[] arr = new int[1][2];
表示当前这个二维数组可以存储1个一维数组, 每一个一维数组中可以存储2个元素
12.二维数组内存图
存储一维数组,即一维数组的地址值。
13.打乱二维数组
分析:
- 打乱一维数组
- 动态初始化一个二维数组, 准备存储打乱之后的数据
- 将打乱后的数据, 存入二维数组当中
import java.util.Random;
public class Test1 {
/*
需求: 打乱二维数组
1. 准备一维数组并打乱
2. 准备二维数组, 准备存储打乱之后的数据
3. 将打乱后的数据, 存入二维数组中.
*/
public static void main(String[] args) {
// 1. 准备一维数组并打乱
int[] nums = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
Random r = new Random();
for (int i = 0; i < nums.length; i++) {
int index = r.nextInt(nums.length);
// nums[i] nums[index]
int temp = nums[i];
nums[i] = nums[index];
nums[index] = temp;
}
// 2. 准备二维数组, 准备存储打乱之后的数据
int[][] arr = new int[4][4];
// 3. 将打乱后的数据, 存入二维数组中.
int a = 0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
arr[i][j] = nums[a];
a++;
}
}
// 4. 遍历二维数组并打印.
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
}