概念：一组连续的存储空间，存储多个相同数据类型的数据
语法
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}};