热门标签
热门文章
- 1联想台式电脑液晶显示器按最左边键出现黑屏_按显示器上最左边按钮后显示器黑屏
- 2开源模型应用落地-LangChain高阶-集成vllm-QWen1.5-OpenAI-Compatible Server（三）_langchain 集成qwen
- 3LeetCode 316 周赛
- 4微信小程序开发学习笔记——4.8【小案例】初识wx.request获取网络请求并渲染至页面_微信小程序网络请求实例
- 5【个人笔记/Java】JavaSE（三）数组_javaweb数据库定义数组储存
- 6共探数字技术与信息安全，第四届中俄数字论坛成功举办_andrey krutskikh
- 7怎么使用Stable diffusion中的models_stable diffusion模型models
- 8SQL Server - 函数用法_sqlserver函数写法
- 9自然语言处理(NLP)——LDA模型:对电商购物评论进行情感分析_nlp 电商产品评论数据情感分析
- 10软件测试面试题 | 工作5年面试16家，总结大环境下的软件测试岗需求与面试常问_3-5年测试工程师面试题
当前位置: article > 正文
Java—数组知识点梳理_java关于数组重要知识点
作者：煮酒与君饮 | 2024-07-03 10:05:55
赞
踩
java关于数组重要知识点
注：本文章内容多数来自哔站尚硅谷视频课程，整理于此方便后续查看
一、数组声明
1.数组概念
数组是相同数据类型的元素按一定顺序排列的集合。使用数组可以将同一类型的数据存储在连续的内存位置。
2.数组特点
- 数组中各元素类型相同
- 通过下标访问数组中各元素(
下标从0开始) - Java中数组是一个对象(
类是一个限定范围，对象是范围内的具体事物) - 数组元素可以是基本数据类型、类类型或接口类型，也可以是数组
3.数组声明(定义)格式
类型 数组名[ ]或类型[ ] 数组名
类型–>数组元素类型
数组名–>合法标识符(确定一个数组)
[ ]–>确定创建的是一个数组类型变量(数组标志)
在定义数组时不会为数组分配内存，故方括号中不需要指明数据元素个数即数组长度。声明的数组名只是应用变量，用于指向一个数组
Java中没有静态数组定义，故不能写int testArry[5]，正确写法为int testArry[]
二、创建数组
1. 数组声明只是定义了一个数组应用，只有初始化后才能使用数组的元素。故初始化的过程就是创建数组的过程
- 静态初始化：在
定义数组同时给数组元素赋初值，使用一对大括号将初值括起来，每个元素对应一个引用
//类型[] 数组名 = {初值1，初值2……};
int[] testArry = {1,2,3,4}//定义了4个元素int型数组
- 1
- 2
- 动态初始化：使用
运算符new为数组分配空间，方括号内数字表示元素个数
//类型[] 数组名 = new 类型 [数组大小]
int[] testArry = new int[4];
- 1
- 2
2.类类型的数组，使用new只为数组本身分配了空间，而对于数组元素并没有初始化，故类类型数组空间分配需要经过两步
2.1 格式：
类型 数组名[ ] = new 类型[ 数组大小 ];
数组名[0] = new 类型(初值表);
……
数组名[数组大小-1] = new 类型(初值表);
2.2 举例
class Animal{ String name; public Animal(String name){ this.name = name; } public String getName(){ return name; } } class AnimalTest{ Animal[] animals = new Animal[5]; animals[0] = = new Animal("大象"); animals[1] = new Animal("狮子"); animals[2] = new Animal("老虎"); animals[3] = new Animal("犀牛"); animals[4] = new Animal("长颈鹿"); for (int i = 0; i < animals.length; i++) { System.out.println(animals[i].getName()); }//返回地址，因为此处为引用数据类型，所指向的是对象所在的地址，而不是对象本身，需要调用函数获取相应对象，如下 for (int j = 0; j < animals.length; j++) { System.out.println(animals[j].getName()); } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
三、数组的内存
1.虚拟机栈：用于存放方法中声明的变量，存放数组地址(首地址)。如arr
2.堆：用于存放数组的实体（数组中的所有元素）。如1,2,3
3.对于二维数组的内存结构：
1.二维组方法名位于栈中，存放外存数组地址(首地址)
2.二维数组的外层数组元素存放内层数组地址位于堆中
3.二维数组的内层数组元素存放数组实体(元素)位于堆中
- 1
- 2
- 3
- 4
- 5
- 6
四、数组间的赋值及数组中常用算法
数组间赋值：
1.类型一致(都为整型、字符型、浮点型……)
2.维度一致(都为一维或二维)
数组常用算法:
数值型数组的特征值计算：最大值、最小值、总和、平均值
数组元素的赋值：杨辉三角、生成随机数……
数组的复制、赋值：前者是新开辟空间，后者是新建一个变量
数组的反转
数组的扩容和缩容
数组的查找：线性、二分(有序）
数组排序：冒泡、快速
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
五、数组初始化代码
public class ArrExer01 { public static void main(String[] args){ //1.数组的声明与初始化-->数组初始化完成则长度确定且不可变 //1.1静态初始化 int[] arr1 = new int[]{1,2,3,4,5};//表示1 System.out.println(arr1);//打印数组地址值，结构为‘类型’+@+地址值 System.out.println(arr1[0]+arr1[1]+arr1[2]+arr1[3]+arr1[4]);//打印数组内容 int[] arr2 = {1,2,3,4,5};//表示2 System.out.println(arr2); System.out.println(arr2[0]+arr2[1]+arr2[2]+arr2[3]+arr2[4]); //1.2动态初始化,确定空间大小但没有赋予内容 int[] arr3 = new int[5]; arr3[0] = 1; arr3[2] = 3; arr3[4] = 5; for (int i = 0; i < arr3.length; i++) {//数组遍历 System.out.print(arr3[i]); } System.out.println("------cut line------"); //2.数组元素默认初始化值 //2.1 整型数组默认初始化值 int[] i_arr = new int[3]; System.out.println(i_arr[0]);//默认值为0 //2.2 浮点型数组默认初始化值 double[] d_arr = new double[3]; System.out.println(d_arr[0]);//默认值为0.0 //2.3 字符型数组默认初始化值 char[] c_arr = new char[3];//默认值为0，不为‘0’，或理解为‘\u0000’ System.out.println(c_arr[0]); //判断char默认值到地为多少 if(c_arr[0] == 0){ System.out.println("char's default is 0!"); } if(c_arr[0] == '0'){ System.out.println("char's default is '0'!"); } //2.4 boolean(布尔)型数组默认初始化值 boolean[] b_arr = new boolean[3];//默认值为false System.out.println(b_arr[0]); //2.5 引用数据类型数组默认初始化值；此处String为引用数据类型，但因为JVM特殊处理后，可以返回对象值而不是地址值 String[] s_arr = new String[3];//默认值为null System.out.println(s_arr[0]); System.out.println("------cut line------"); //3.二维数组初始化与赋值 //3.1 静态初始化 int[][] arr4 = new int[][]{{1,2,3},{1,2,3,4},{1,2}};//表示方法1 int[] arr5[] = {{1,2,3},{1,2,3,4},{1,2}};//表示方法2 int arr6[][] = {{1,2,3},{1,2,3,4},{1,2}};//表示反法3 System.out.println(arr4);//打印二维数组地址 System.out.println(arr4[0]);//打印二维数组中的其中一个一维数组地址值 System.out.println(arr4[0][0]+arr4[0][1]+arr4[0][2]); //3.2 动态初始化 int[][] arr7 = new int[3][3]; arr7[0][0] = 1; arr7[1][1] = 2; arr7[2][2] = 3; for (int i = 0; i < arr7.length; i++) {//数组遍历 for (int j = 0; j < arr7[i].length; j++) { System.out.print(arr7[i][j]); } } System.out.println(); int[][] arr8 = new int[3][]; System.out.println(arr8.length);//二维数组中一维数组数 //System.out.println(arr8[0].length);//二维数组中的一个一维数组中元素个数数，此处因后一个值为空，故此代码不可执行 System.out.println("------cut line------"); //4.二维数组默认初始化值 //4.1 整型 int[][] ii_arr = new int[4][4]; //4.1.1 外层元素默认初始化值 System.out.println(ii_arr[0]);//地制值 //4.1.2 内层元素默认初始化值 System.out.println(ii_arr[0][0]);//0 //4.2 boolean(布尔)型 boolean[][] bb_arr = new boolean[4][4]; //4.2.1 外层元素默认初始化值 System.out.println(bb_arr[0]);//地制值 //4.2.2 内层元素默认初始化值 System.out.println(bb_arr[0][0]);//false //4.…… System.out.println("------cut line------"); //特别注意 int[][] ii_arr1 = new int[4][]; System.out.println(ii_arr1[0]);//地址 System.out.println(ii_arr1[0][0]);//空指针异常 } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
六数组常用算法代码
1.1 计算及赋值
public class ArrExer02 { public static void main(String[] args){ int[] arr = new int[10];//动态创建数组 for (int i = 0; i < arr.length; i++) {//循环赋值 arr[i] = (int)(Math.random() * (99 - 10 + 1)) + 10;//创建一个0-99的随机数 } //1.数组计算 //1.1 求最大值 int max = arr[0]; for (int i = 0; i < arr.length; i++) { if(max < arr[i]){ max = arr[i]; } } System.out.println("最大值为：" + max); //1.2 求最小值 int min = arr[0]; for (int i = 0; i < arr.length; i++) { if(min > arr[i]){ min = arr[i]; } } System.out.println("最小值为：" + min); //1.3 求总和 int sum = 0; for (int i = 0; i < arr.length; i++) { sum += arr[i]; } System.out.println("总和为："+sum); //1.4 求平均值 int avgValue = sum / arr.length; System.out.println("平均值为："+avgValue); //2.数组的赋值、复制 int[] arr1,arr2;//创建两个数组 arr1 = new int[]{2,3,4,5,6,7,8,9}; //2.1 赋值 for (int i = 0; i < arr1.length; i++) { System.out.print(arr1[i] + " "); } arr2 = arr1;//数组1赋值给数组2，可以发现其地址也改变 System.out.println(); System.out.println("数组1地址：" + arr1);//打印数组1的地址 System.out.println("数组1赋值给数组2后数组2地址：" + arr2);//第一次打印数组2的地址 for (int i = 0; i < arr2.length; i++) { if(i % 2 == 0){ arr2[i] = i;//改变数组2中的值 } } for (int i = 0; i < arr1.length; i++) {//打印数组1发现值也被改变 System.out.print(arr1[i] + " "); } System.out.println(); //2.2 复制 arr2 = new int[arr1.length]; for (int i = 0; i < arr2.length; i++) { arr2[i] = arr1[i]; System.out.print(arr2[i] + " "); } System.out.println(); System.out.print("新建空间后数组2地址：" + arr2);//第二次打印数组2的地址 } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
1.2 查找
public class ArrExer03 { public static void main(String[] args) { int[] testArr = new int[]{33,5,26,7,28,37,44,65,43,21,8,9}; System.out.print("原数组："); for (int i = 0; i < testArr.length; i++) { System.out.print(testArr[i] + " "); } System.out.println(); ArrMethod methodArr = new ArrMethod(); //1.数组元素反转 System.out.print("反转操作后数组："); //methodArr.swapMethod1(testArr); //System.out.println(); methodArr.swapMethod2(testArr);//方法1和2同时执行恢复为原来的顺序 System.out.println(); //2.数组的扩容和缩容 //2.1数组扩容 int[] inputArr = new int[]{111,112,113,114}; System.out.print("扩容后数组："); methodArr.dilatationArr(testArr,inputArr); System.out.println(); //2.2数组缩容 int deleteIndex = 5; System.out.print("缩容后数组："); //methodArr.reduceArr1(testArr,deleteIndex); //System.out.println(); methodArr.reduceArr2(testArr,deleteIndex); System.out.println(); //3.数组元素的查找 System.out.print("查找数组数据："); int findFigure = 44; //3.1线性查找 methodArr.findArr1(testArr,findFigure); System.out.println(); //3.2二分查找 //二分查找必须在有序的数组中才能起效 int[] testArr1 = new int[]{3,5,6,7,9,10,12,15,16,17}; int findFigure1 = 10; methodArr.findArr2(testArr1,findFigure1); System.out.println(); } } class ArrMethod{ public void swapMethod1(int[] arr){//方法1，不新建数组 for (int i = 0; i < arr.length/2; i++) {//此处需要为length/2，否则会变成原来数组顺序 //交换arr[i]与arr[arr.length-1-i]位置的元素 int temp = arr[i]; arr[i] = arr[arr.length-1-i]; arr[arr.length-1-i] = temp; } System.out.println("方法1"); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } } public void swapMethod2(int[] arr){//方法2，新建数组 int[] newArr = new int[arr.length]; for (int i = 0; i < arr.length; i++) { newArr[i] = arr[arr.length-1-i]; } arr = newArr; System.out.println("方法2："); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } } public void dilatationArr(int[] arr1,int[] arr2){ int[] newArr = new int[arr1.length * 2];//扩容到原数组2倍 for (int i = 0; i < arr1.length; i++) {//此处不能用newArr的长度，不然会数组越界 newArr[i] = arr1[i]; } for (int i = 0; i < arr2.length; i++) { newArr[arr1.length + i] = arr2[i]; } arr1 = newArr; for (int i = 0; i < arr1.length; i++) { System.out.print(arr1[i] + " "); } } public void reduceArr1(int[] arr,int deleIndex){//方法1，不新建数组，在原数组中删除数组下标 for (int i = deleIndex; i < arr.length - 1; i++) { arr[i] = arr[i + 1]; } //修改最后一个元素，设置为默认值 arr[arr.length - 1] = 0; for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } } public void reduceArr2(int[] arr,int deleIndex){//方法2，新建数组 int[] newArr = new int[arr.length-1]; for (int i = 0; i < deleIndex; i++) { newArr[i] = arr[i]; } for (int i = deleIndex; i < newArr.length; i++) {//此处newArr.length也可换为arr.length-1 newArr[i] = arr[i+1]; } arr = newArr; for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } } public void findArr1(int[] arr,int target){ boolean isFlag = true; for (int i = 0; i < arr.length; i++) { if(target == arr[i]){ System.out.print("找到" + target + ",对应位置为：" + i); isFlag = false; break; } } if(isFlag){//或将isFlag替换为 i==arr.length System.out.print("未找到此元素："); } } public void findArr2(int[] arr,int target){ int head = 0,end = arr.length-1; boolean isFlag = true; while(head <= end){ int middle = head + end; if(target == arr[middle]){ System.out.print("找到元素" + target + "，对应位置为：" + middle); isFlag = false; break; }else if(target < arr[middle]){ end = middle - 1; }else{//target > arr[middle] head = middle +1; } } if(isFlag){//或将isFlag替换为head > end System.out.print("未找到该元素"); } } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
七、思考
为什
int[ ]的数组可以直接打印出数值，而Animal[ ]的数组必须调用方法才能打印出结果？
解答：
基本数据类型数组的数组元素依然是基本数据类型，所以当定义int[] i_arr = new int[2]时候，通过打印可得到i_arr[0] = 0;
引用类型数组的数组元素依然是引用数据类型，需要使用new分配空间，不存储对象值，只保留指向对象的地址，所以打印引用数据类型打印出的就是地址值(见**二**==>**2.2**)
public class Animal { String name; public Animal(){} public Animal(String name){ this.name = name; } public String getName(){ return name; } } class AnimalTest{ public static void main(String[] args) { Animal animal = new Animal(); System.out.println("引用地址" + animal); } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/煮酒与君饮/article/detail/782731
推荐阅读
相关标签
