3.1 数组的声明
按一定顺序排列的同类型数据的集合称为数组,本身是一种引用类型
int[] arr; //数组元素类型[] 数组名;
int arr[]; //数组元素类型 数组名[]; //不推荐
3.2 数组的初始化
//静态初始化
// 数组名 = new 数组元素数据类型[] {元素1,元素2,元素3,...}
//在堆空间开辟一块内存区域来存储数组的元素(new)
// 将该内存区域的地址值赋给该数组的引用变量arr(引用)
int[] arr = new int[] {1,2,3};
//简单写法,必须声明的同时做初始化
// 数组元素类型[] 数组名 = {元素1,元素2,...}
int[] arr1 = {1,2,3};
//动态初始化,系统自动为数组元素分配初始值
//数组元素类型[] 数组名 = new 数组元素类型[length]
int[] arr2 = new int[3] ;//0,0,0
- 变量必须初始化后才能使用
- 数组是定长的:数组一旦初始化完成,数组的长度就固定了,不能更改,除非重新做初始化
- 数组是引用数据类型,可以赋值为 null,表示没有引用任何内存空间
- new 关键字:在堆空间开辟一块内存区域,用来存储数据
- 操作数组常见异常:NullPointerException:空指针异常(没有引用地址值)ArrayIndexOutOfBoundsException:数组的索引越界异常
3.3 数组的基本操作
float[] arr = new float[10]; // arr可以装10个float数据
int[] arr2 = new int[8]; // arr2可以装8个int数据
String[] arr3 = new String[7]; //arr3 可以装7个String数据
arr[0] = 1.8;
arr2[2]=5;
arr3[1] = "zhangsan";
//如果要批量自动装数据:用for循环
for(int i=0;i<10;i++){
arr[i] = i;
}
int[] arr = new int[] {1,2,3};
//访问数组元素, 数组变量[索引值]
int len = arr.length; //数组长度,length 是属性,索引范围[0,arr.length -1 ]
int num = arr[0];
arr[0] = 11;
//遍历
//普通for 循环
for (int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
//增强for循环(for-each)
//只能访问数组元素,不能赋值,不关心数组的索引时使用
//当数组元素是引用类型时,不建议使用(需要先知道值不为null的元素个数)
for (int lel:arr){
System.out.println(lel);
}
//反编译后
int ai[] = arr;
int k = ai.length;
for (int j=0;j<k;j++){
// 使用循环迭代出数组中的每一个元素并赋值给i
int i = ai[j];
System.out.println(i);
}
//打印数组元素
//直接打印数组名时,打印出来是数组对应 的hashCode值,如[D@15db9742, [Ljava.lang.String;@15db9742
}
static String toString(int[] arr){
//判断数组是否为空
if (arr == null) {
//结束方法
return "null";
}
if (arr.length == 0){
return "[]";
}
//先拼接"["
String ret = "[";
for (int index = 0;index<arr.length;index++) {
//如果不是最后一个元素,拼接元素 + "," ,否则拼接元素 + "["
ret = (index != arr.length -1) ? ret + arr[index] + "," :ret + arr[index] + "]";
}
return ret;
}
3.4 常见的数组算法操作
//冒泡排序, 平均时间复杂度 o(n^2),空间复杂度o(1)
//对未排序的各元素从头到尾依次比较相邻的两个元素 arr[i],arr[i+1]
//共要进行arr.length - 1轮
// 第 times 轮还剩 arr.length - (time - 1) 个元素
// times [1, arr.length -1] i [0, arr.length- (time - 1) - 2]
static void bubbleSort(int[] arr) {
for (int i = 0;i<arr.length;i++) {
for (int j = 0;j < arr.length-1-i;j++) {
if (arr[j] > arr[j+1]) {
arr[j] = arr[j] ^ arr[j+1];
arr[j+1] = arr[ j ] ^ arr[j+1];
arr[j] = arr[j] ^ arr[j + 1];
}
}
}
for (int i = 0;i<arr.length;i++) {
for (int j = 0;j < arr.length-1-i;j++) {
if (arr[j] > arr[j+1]) {
int tmp = arr[j];
arr[j] = arr[j+1] ;
arr[j+1] = tmp;
}
}
}
}
// 选择排序,平均时间复杂度 O(n^2),空间复杂度 O(1)
// 假定未排序序列的起始位置的元素 arr[i] 为最小值,依次去比较剩下的元素 arr[j]
// i [0, arr.length - 2] j [i + 1, arr.length - 1]
static void selectionSort(int[] arr) {
for (int i =0;i<arr.length -2;i++){
for (int j=i+1;j<=arr.length-1;j++) {
if (arr[i] > arr[j]) {
//交换
arr[i] = arr[i] ^ arr[j];
arr[j] = arr[i] ^ arr[j];
arr[i] = arr[i] ^ arr[j];
}
}
}
}
// 从有序数组中查找 key 第一次出现的位置
// 二分搜索法/二分查找法/折半查找
// 前提:数组的元素是有序排列的
// 区间位置:如果 arr[mid] != key,下一次是以 mid + 1 作为下一个起始位置,或者 mid - 1 作为下一个结束位置
// 退出循环的条件:low > high
static int binarySearch(int[] arr, int key) {
int low = 0;
int high = arr.length-1;
while (low <= high) {
int mid = (low + high) >> 1;
if (arr[mid] <key) {
low = mid +1;
}else if(arr[mid] >key) {
high = mid - 1;
}else {
while (mid - 1 >= 0 && arr[mid -1] == key) {
mid--;
}
return mid;
}
}
return -1;
}
3.5 二维数组
实质还是一维数组, 其数组元素是引用类型( 数组类型), 数组元素里保存的引用指向一维数组
- 同时初始化二维数组的两个维数后的存储示意图
- 定义格式
// 静态初始化
int[][] arr = new int[][] { {1, 2, 3}, {4, 5}, {6} };
int[][] arr = { {1, 2, 3}, {4, 5}, {6} };
// 动态初始化
int[][] arr = new int[3][]; // 等同于 int[][] arr = {null, null, null};
int[][] arr = new int[3][4];
// arr.length 为外层数组的长度,arr[i].length 为内层每个数组的长度
// 遍历
// 普通 for 循环
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
System.out.println(nums[i][j]);
}
}
// 增强 for 循环(for-each)
int totalLength = 0; // 元素的总个数
for (int[] outerArr : arr) {
for (int ele : outerArr)
System.out.println(ele);
totalLength ++;
}
}
3.6 操作数组的工具类
- Java.lang.System类中数组拷贝的类方法
void arraycopy(Object src, int srcPos, Object dest, int destPos, int length):从 源数组 src 的 srcPos 位置 复制元素到 目标数组 dest 的 destPos 位置,复制的数组元素的个数为 length
3.7Arrays
Java.util.Arrays 中的类方法:
- String toString(Object[] arr):将 a 数组转换成一个字符串,括在方括号("[]")中,相邻元素用字符 ", "(逗号加空格)分隔
- void sort(Object[] a):根据元素的自然顺序对指定对象数组按升序进行排序,数组中的所有元素都必须实现 Comparable 接口(对于原始数据类型,使用所谓双轴快速排序(Dual-Pivot QuickSort),对于对象数据类型,使用 TimSort)
- void sort(T[] a, Comparator<? super T> c):根据指定比较器产生的顺序对指定对象数组进行排序
- void parallelSort(Object[] a):以并发的方式对 a 数组的数组元素进行排序
- void setAll(T[] array, IntFunction generator):使用提供的函数计算每一个元素的值,对指定数组中的所有元素进行设置
- void parallelSetAll(T[] array, IntFunction generator):以并发的方式,使用提供的函数计算每一个元素的值,对指定数组中的所有元素进行设置
- type binarySearch(Object[] a, type key):使用二分法査询 key 元素值在 a 数组中出现的索引,如果 a 数组不包含 key 元素值,则返回 -(low + 1)(调用该方法时要求数组中元素已经按升序排列)
- boolean equals(Object[] a, Object[] a2):如果 a 数组和 a2 数组的长度相等,且 a 数组和 a2 数组的数组元素也一一相同,该方法将返回 true
- Object[] copyOf(Object[] original, int newLength):复制 original 数组,截取或用 0(数值类型)、false(布尔类型)或者 null(引用类型)填充,以使新数组的长度为 newLength
- List asList(T… a):把一个引用类型的数组或指定个数的对象转换成固定长度的 List(Arrays.ArrayList),只能遍历访问该集合里的元素,不可增加、删除该集合里的元素,否则会引发 UnsupportedOperationException 异常
Integer[] integers = list.toArray(new Integer[0]); // List<Integer> 转 Integer[]
List<Integer> list = Arrays.asList(integers); // Integer[] 转 List<Integer>
Integer[] integers = Arrays.stream(ints).boxed().toArray(Integer[]::new); // int[] 转 Integer[]
int[] ints = Arrays.stream(integers).mapToInt(Integer::valueOf).toArray(); // Integer[] 转 int[]
List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList()); // int[] 转 List<Integer>
int[] ints = list.stream().mapToInt(Integer::valueOf).toArray(); // List<Integer> 转 int[]