概念:一组连续的存储空间,存储多个相同数据类型的数据
语法
1.声明数组 数据类型[] 数组名;
int[] a; int []a; int a[];
2.分配空间 数组名 = new 数据类型[数组长度];
a = new int[4];
1)多种声明方式
声明的同时并且分配空间 int [] a = new int[4];
显示初始化
int [] a = new int [] {1,2,3,4,5};
int [] a = {1,2,3,4,5};
2)数组元素具有默认值
数组类型 0/0.0
char 类型 空字符 0 '\u0000'
布尔类型 false
引用数据类型(String) null
3.数组的下标: 0-数组长度-1
注意:当访问超出下标范围的元素时,会运行报错
报错信息为:java.lang.ArrayIndexOutOfBoundsException(数组下标越界)
4.元素访问: 数组名[下标] ;
a[1]
5.数组的长度:数组名.length
a.length
6.数组的遍历
for(int i=0;i<a.length;i++){
System.out.println("a["+i+"]="+a[i]);
}
数组的特点:内存空间是连续的
1.优势:数组名中存储的是数组的首地址,方便通过首地址去查找任意元素
查询快,能够快速的查找到所需要的元素
元素地址 = 数组的首地址+字节数*下标
2.劣势:数组长度固定
数组的扩容
1.新建一个数组,长度大于原数组 循环将原数组中所有元素逐一赋值给新数组。
//1. 新建一个长度更大的数组
int[] b = new int[a.length*2];
//2. 将旧数组中的元素 一一 挪到新数组
for(int i=0;i<a.length;i++){
b[i] = a[i];
}
//3. 将新数组的地址 赋值给旧数组
a = b;
2.借助Arrays工具类
java.util.Arrays.copyOf(需要扩容的数组,扩容的长度); //返回扩容后的数组
a = java.util.Arrays.copyOf(a,a.length*2);
System.arraycopy(原始数组,起始下标,新数组,存储元素的起始下标,长度);
//将旧数组中的元素一一挪到新数组
System.arraycopy(a,0,b,0,a.length);
数组作为参数 :实参赋值给形参的是地址 。形参和实参指向同一块空间
数组作为返回值:返回的是地址
可变长参数
概念:可以接收多个参数,不限个数。可以看作数组。
语法:数据类型...变量名;
int...a
注意:可变长参数,只能定义在形参列表的最后
数组的排序
1.冒泡排序:将相邻的两个元素进行比较,并且交换位置
//从小到大
for(int i=0;i<a.length-1;i++){ //外层循环 确定比较的轮数
for(int j=0;j<a.length-1-i;j++){ //j表示元素的下标
if(a[j]>a[j+1]){ //相邻的两个元素做比较
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
2.选择排序:拿固定元素与后面元素一一比较,交换位置
for(int i=0;i<a.length-1;i++){ //固定元素对应得下标
for(int j = i+1;j<a.length;j++ ){ //后面元素对应得下标
if(a[i]>a[j]){
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
3.JDK排序
java.util.Arrays.sort(数组名); //升序排列
二维数组
概念:一维数组中的一维数组,元素也是一个数组
语法:
1.声明并分配空间
数据类型[][] 数组名 = new 数据类型[行号][列号];
int[][] a = new int[3][4];
2.二维数组的元素访问数组名[行号][列号];
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++){
System.out.print(a[i][j]+"\t");
}
System.out.println();
}
不规则数组
int[][] a = new int[3][];
a[0] = new int[4];
a[1] = new int[2];
a[2] = new int[5];
int[][] a = {{10,9,7},{20,15,18,19},{20,30,40,50,60},{1,12}};