JavaSE-数组
1.一维数组
1.1 数据结构（合理选用数据结构能有效提升程序存储雄效率和运行效率）
* 数据结构：计算机中保存和组织数据的一种方式，保存方式不同，操作效率也不同
*
1.2 数组特性
* （1）连续存储，确定长度后不能修改，下标从0开始，有length属性保存个数
* （2）查询操作效率高，添加及删除操作效率低（因为需要不断地创建空间和移动数据）
* （3）Java中数组没有提供添加和删除操作，需要自己完成
*
1.3 数组声明
* 1.3.1 静态声明：在元素值已知的时候，使用静态声明
* 数据类型[] 变量名 = {值, 值, 值...}
* 数据类型 变量名[] = {值, 值, 值...}
* 数据类型[] 变量名 = new 数据类型[]{值, 值, 值...}
//静态声明
int[] arr1 = {1, 2, 3, 4};
int arr2[] = {4, 5, 6, 7};
int[] arr3 = new int[] {7, 8, 9, 10};* 1.3.2 动态声明：不知道每个元素值的时候使用动态声明.
* 数据类型[] 变量名 = new 数据类型[长度]
//动态声明
int[] arr4 = new int[10];* 注：如果是动态声明，数组中保存的是对应的默认值
* 整形： 0 浮点型： 0.0 布尔型： false 字符型：\u0000 引用型：null
1.4 数组是引用类型,保存在堆内存中，栈内存中只保留了堆内存的内存地址
1.5 数组的使用
* 1.5.1 获取数据
查询：数组[下标] 数组下标从0开始
//查询
System.out.println(array[2]);* 1.5.2 更改数据
修改：数组[下标] = 值
//更改
array[3] = 11;
System.out.println(array[3]);* 1.5.3 遍历数据
遍历(最后一个元素下标是数组长度-1)
//遍历
for (int i = 0;i < array.length; i++) {
System.out.println(array[i]);
}* 1.5.4 常见异常
下标越界： java.lang.ArrayIndexOutOfBoundsException
* 当下标小于0或大于等于length时，会出现下标越界
* 1.5.5 数组传递
当调用一个方法并且需要传入数组的时候
(1).传递的是已经创建好的数组
(2).传递字面量
public static void main(String[] args) {
int[] array = {2, 4, 5, 7, 9};
//传递创建好的数组
m1(array);
//传递字面量
m1(new int[] {1, 4, 6, 9});
}
public static void m1(int[] arr) {
for (int i = 0;i < arr.length; i++) {
System.out.println(arr[i]);
}
}1.6 传值和传址/传值和传引用
* 传值：指的是基本数据类型传递
* 传址：指的是引用数据类型的传递
public static void main(String[] args) {
//基本数据类型传递
int age = 10;
m1(age);
System.out.println("main: " + age);
//引用数据类型的传递
int[] ages = {12, 18, 23, 55, 60};
m2(ages);
System.out.println("main: " + ages[0]);
}
//传值，m1方法内age改变不影响main方法中的age
public static void m1(int age) {
age--;
System.out.println("m1: " + age);
}
//传址，m2方法中的ages[0]改变，影响数组对应的值的改变
public static void m2(int[] ages) {
ages[0] = 12;
System.out.println("m2: " + ages[0]);
}1.7 数组替换复制
public static void main(String[] args) {
//源数组
int[] src = {1, 2, 3, 4, 5, 6, 7};
//目标数组
int[] dest = {11, 12, 13, 14, 15, 16, 17};
//源数组起始位置
int srcIndex = 1;
//目标数组起始位置
int destIndex = 2;
//复制个数
int length = 3;
copy(src,srcIndex,dest,destIndex,length);
//调用Api
//System.arraycopy(src, srcIndex, dest, destIndex, length);
for (int i = 0;i < dest.length;i++) {
System.out.println(dest[i]);
}
}
//使用for循环复制
public static void copy(int[] src, int srcIndex, int[] dest
, int destIndex, int length) {
for(int i = 0; i < length; i++) {
dest[destIndex] = src[srcIndex];
srcIndex++;
destIndex++;
}
}1.8 数组插入复制
public static void main(String[] args) {
//源数组
int[] src = {1, 2, 3, 4, 5, 6, 7};
//目标数组
int[] dest = {11, 12, 13, 14, 15, 16, 17};
//源数组起始位置
int srcIndex = 2;
//目标数组起始位置
int destIndex = 2;
//复制个数
int length = 3;
int[] newDest = copy(src, srcIndex, dest, destIndex, length);
//遍历输出新数组
for(int i = 0;i < newDest.length;i++) {
System.out.println(newDest[i]);
}
}
public static int[] copy(int[] src, int srcIndex, int[] dest
, int destIndex, int length) {
//定义新数组，新数组长度 = 目标数组长度 + 插入个数
int[] newDest = new int[dest.length + length];
//1.把目标数组的0到起始位置的数据先放到新数组中
for(int i = 0;i <= destIndex; i++) {
newDest[i] = dest[i];
}
//2.把源数组中，起始位置到起始位置+length结束的值放到新数组中
//定义临时量index存储destIndex+1的位置
int index = destIndex + 1;
for(int i = srcIndex; i < srcIndex + length;i++) {
newDest[index] = src[i];
index++;
}
//3.把目标数组中剩余的值放到新数组中
for(int i = destIndex + 1; i < dest.length;i++) {
newDest[index] = dest[i];
index++;
}
return newDest;
}2. 二维数组
2.1 声明方式
* 静态二维数组
* 数据类型[][] 变量名 = {{值,值,值...}, {值,值,值...}, {值,值,值...}}
* 数据类型[][] 变量名 = new 数据类型[][]{{值,值,值...}, {值,值,值...}, {值,值,值...}}
//静态
int[][] arr1 = {{1,2,3},{3,4,5},{6,7,5},{8,7,9}};
int[][] arr2 = new int[][]{{1,2,3},{3,4,5},{6,7,5},{8,7,9}};* 动态二维数组
* 数据类型[][] 变量名 = new 数据类型[5][6]
//动态
int[][] arr3 = new int[5][2];2.2 使用方式
* 2.2.1 获取数据
* 查询：数组[下标][下标] 数组下标从0开始
第一个下标是查询二维数组中的哪个一维数组
第二个下标是查询一维数组中的第几个元素
public static void main(String[] args) {
//静态
int[][] arr1 = {{1,2,3},{3,4,5},{6,7,5},{8,7,9}};
//查询
//查询并打印二维数组中第一个一维数组的第二个元素
System.out.println(arr1[0][1]);
//查询二维数组中最后一个一维数组的最后一个元素
System.out.println(arr1[arr1.length - 1][arr1[arr1.length-1].length-1]);
}* 2.2.2 更改数据
* 修改：数组[下标][下标] = 值
public static void main(String[] args) {
int[][] arr2 = new int[][]{{1,2,3},{3,4,5},{6,7,5},{8,7,9}};
//修改
//将二维数组arr2中的第二个一维数组的第一个元素修改为12
arr2[1][0] = 12;
}* 2.2.3 遍历数据
* 两层循环语句
public static void main(String[] args) {
int[][] arr1 = {{1,2,3},{3,4,5},{6,7,5},{8,7,9}};
//遍历
for(int i = 0; i < arr1.length; i++) {
for(int j = 0; j < arr1[i].length; j++) {
System.out.print(arr1[i][j] + " ");
}
System.out.println();
}
}* 2.2.4 动态声明锯齿状（在二维数组中需要单独声明每一个一维数组的长度时）
* 如：int[][] array = new int[5][];只初始化二维数组长度
public static void main(String[] args) {
//动态声明二维数组，并且使每一个一维数组的长度可以不同
int[][] array = new int[4][];
//需要单独初始化每一个一维数组
for(int i = 0; i < array.length; i++) {
array[i] = new int[i + 1];
}
//遍历
for(int i = 0; i < array.length; i++) {
for(int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
}3. 交换变量的值(补充)
public static void main(String[] args) {
int a = 3;
int b = 5;
//1.中间变量(常用)
int temp = a;
a = b;
b = temp;
System.out.println("a = " + a + ";" + "b = " + b);
//2.加减法
a = 3;
b = 5;
a = a + b;
b = a - b;
a = a - b;
System.out.println("a = " + a + ";" + "b = " + b);
//3.位异或
a = 3;
b = 5;
a = a ^ b;
b = a ^ b;
a = a ^ b;
System.out.println("a = " + a + ";" + "b = " + b);
}