- 按一定顺序排列的同类型数据的集合称为数组,本身是一种引用类型
声明
初始化
// 数组名 = new 数组元素类型[] {元素 1, 元素 2, ...};
// 在堆空间开辟一块内存区域来存储数组的元素(new)
// 将 该内存区域的地址值 赋值给 该数组的引用变量 arr(引用)
int[] arr = new int[] {1, 2, 3};
// 简单写法,必须声明的同时作初始化
// 数组元素类型[] 数组名 = {元素 1, 元素 2, ...};
int[] arr = {1, 2, 3};
// 动态初始化,系统自动为数组元素分配初始值
// 数组名 = new 数组元素类型[length];
int[] arr = new int[3]; // [0, 0, 0]
数组是定长的:数组一旦初始化完成,数组的长度就固定了,不能更改,除非重新做初始化
new 关键字:在堆空间开辟一块内存区域,用来存储数据
基本操作
常见的数组算法操作
// 冒泡排序,平均时间复杂度 O(n^2),空间复杂度 O(1)
// 对未排序的各元素从头到尾依次比较相邻的两个元素 arr[i]、arr[i + 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 times = 1; times <= arr.length - 1; times++) {
for (int i = 0; i <= arr.length - times - 1; i++) {
if (arr[i] > arr[i + 1]) {
// 交换
arr[i + 1] = arr[i] ^ arr[i + 1];
arr[i] = arr[i] ^ arr[i + 1];
}
}
}
}
// 从有序数组中查找 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) {
} else {
while (mid - 1 >= 0 && arr[mid -1] == key) {
}
return mid;
}
}
return -1;
}
二维数组
实质还是一维数组, 其数组元素是引用类型( 数组类型), 数组元素里保存的引用指向一维数组
- 定义格式
操作数组的工具类
- java.lang.System 类中数组拷贝的类方法
void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
:从 源数组 src 的 srcPos 位置 复制元素到 目标数组 dest 的 destPos 位置,复制的数组元素的个数为 length
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<T> generator)
:使用提供的函数计算每一个元素的值,对指定数组中的所有元素进行设置void parallelSetAll(T[] array, IntFunction<T> generator)
:以并发的方式,使用提供的函数计算每一个元素的值,对指定数组中的所有元素进行设置type binarySearch(Object[] a, type key)
:使用二分法査询 key 元素值在 a 数组中出现的索引,如果 a 数组不包含 key 元素值,则返回 -(low + 1)(调用该方法时要求数组中元素已经按升序排列)boolean equals(Object[] a, Object[] a2)
:如果 a 数组和 a2 数组的长度相等,且 a 数组和 a2 数组的数组元素也一一相同,该方法将返回 trueObject[] copyOf(Object[] original, int newLength)
:复制 original 数组,截取或用 0(数值类型)、false(布尔类型)或者 null(引用类型)填充,以使新数组的长度为 newLengthList<T> 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>