1.数组的概念
概念：一组连续的存储空间，存储多个相同数据类型的值
特点：类型相同，长度固定。
2.数组的创建、访问、遍历
-
创建语法：
①声明并分配空间
数据类型[] 变量名 = new 数据类型[数组大小值];
eg:
int[] arr = new int[5];
②先声明，再分配空间
数据类型[] 变量名;
变量名 = new 数据类型[数组大小值];
eg:
int[] arr;
arr = new int[5];
③声明并赋值(繁)
数据类型[] 数组名 = new 数据类型[]{value1, value2, value3, ...};
eg:
int[] arr = new int[]{11, 22, 33, 44, 55, 66};
④声明并赋值(简)
数据类型[] 数组名 = {value1, value2, value3, ...};
eg:
int[] arr = {11, 22, 33, 44, 55, 66};
-
访问语法：
数组名[下标];
eg:
int[2];
-
访问数组长度语法：
数组名.length
eg:
arr.length
遍历数组：
for (int i = 0; i < arr.length; i++) {
// arr[i] 使用数组元素
}
3.数组的组成概述：
数组中每个格子称为数组的元素
数组的下标从 0 开始，有效范围：0 ~ 数组长度-1
数组默认值：整数0, 小数0.0, 字符\u0000, 布尔false, 其他null
数组创建之后，长度不可变。
4.数组的扩容
思路：创建一个新的更大的数组，将原数组内容复制到新数组中。
-
三种方式：
1）循环将原数组内容逐一复制到新数组
2）System.arraycopy(原数组, 原数组起始, 新数组, 新数组起始, 长度);
3）java.util.Arrays.copyOf(原数组, 新长度); // 返回带有原数组值的新数组
地址的替换：数组作为引用类型之一，变量存储的是数组的地址；在元素复制后，需要将新数组的地址赋值给原变量，进行地址替换。
5.数组类型参数和返回值
-
数组参数
1）引用数据类型赋值/传参，操作的都是地址值
2）基本数据类型变量无法通过函数传参来修改其原值，只能通过返回值赋值
3）引用数据类型变量可以通过函数传参/返回值赋值修改，因为操作的是地址
eg: public static void func(int[] arr) { }
-
数组返回值
eg: public static int[] func() { }
public class TestParams {
public static void main(String[] args) {
int[] arr = new int[]{11, 22, 33, 44, 55};
// 传入arr数组变量
print(arr);
System.out.println("src: " + arr.length);
System.out.println("************************");
m(arr);
print(arr);
System.out.println("m(arr): " + arr.length);
System.out.println("************************");
arr = m(arr);
print(arr);
System.out.println("arr = m(arr): " + arr.length);
}
// 数组的参数传递
public static int[] m(int[] arr) {
arr[0] = 666;
arr = java.util.Arrays.copyOf(arr, arr.length*2);
return arr;
}
/**
打印输出整数类型数组元素
@arr int类型数组
*/
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
6.可变长数组
概念：可接收多个同类型实参，个数不限，使用方式与数组相同
语法：数据类型... 形参名
-
注意：
支持传递数组类型实参
支持传递零散数据的实参
支持传递的实参的数量为 0~N 个
必须定义在形参列表的最后，且只能有一个
method(xxx, xxx[], xxx...) // 对数组的一种便利写法的补充(80%场景使用数组，20%场景使用可变长参数)
public class TestChangeLength {
public static void main(String[] args) {
int[] nums = {1, 2, 3, 4, 5};
// 1.可变长形参：支持传递数组类型实参
method(nums);
// 2.可变长形参：支持传递零散数据的实参
method(5, 9, 8, 666);
nums = expand(11, 22, 33, 44);
method(nums);
}
// 可变长参数，使用方式与数组无异
public static void method(int... arr) { // 等价于 int[] arr
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static int[] expand(int length, int... arr) {
int[] newNums = new int[length];
System.arraycopy(arr, 0, newNums, 0, arr.length);
return newNums;
}
}
7.数组的排序
-
JDK排序
java.util.Arrays.sort(数组名); // JDK提供，默认升序
降序需要手动进行倒置操作
public class TestJDKSort {
public static void main(String[] args) {
int[] nums = {66, 99, 77, 44, 22, 55, 33, 88, 11};
print(nums);
// JDK排序 - test
java.util.Arrays.sort(nums); // 升序
print(nums); // 11 22 33 44 55 66 77 88 99
// 降序：手动倒置交换值
for (int i = 0; i < nums.length/2; i++) {
int tmp = nums[i];
nums[i] = nums[nums.length-1-i];
nums[nums.length-1-i] = tmp;
}
print(nums); // 99 88 77 66 55 44 33 22 11
}
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
8.二维数组
概念：一维数组中的一维数组；数组中的元素还是数组。
高维数组中的每一个元素，存储了低维数组的地址。
-
声明语法：
先声明、再分配
-
数据类型[][] 数组名;
数组名 = new 数据类型[高维长度][低维长度];
声明并分配空间
数据类型[][] 数组名 = new 数据类型[高维长度][低维长度];
声明并赋值（繁）
-
数据类型[][] 数组名 = new 数据类型[高维长度][]; //不规则数组
数组名[i] = new 数据类型[j]; //自行new低维属组
声明并赋值（简）
数据类型[][] 数组名 = {{v1, v2, v3}, {v4, v5, v6}, {...}}; //显示初始化
public class Test2DArray {
public static void main(String[] args) {
int[][] nums = new int[3][5];
nums[0][0] = 10;
nums[0][3] = 20;
nums[1][0] = 30;
nums[1][1] = 40;
nums[2][2] = 50;
nums[2][4] = 60;
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
System.out.print(nums[i][j] + "\t");
}
System.out.println();
}
System.out.println(nums.length); // 3
System.out.println(nums[0].length); // 5
System.out.println();
System.out.println(nums[0]); // [I@15db9742
System.out.println(nums[1]); // [I@6d06d69c
System.out.println(nums[2]); // [I@7852e922
}
}
