Java数组

数组

本质上就是能 “批量” 创建相同类型的变量（在Java中，数组中包含的变量必须是相同类型）。

数组的定义： 数据类型[] 数组变量名 = new 数据类型[整数]; //整数：数组的长度 数据类型[] 数组变量名 = {值1,值2,值3…值n}; //（静态初始化） 数据类型[] 数组变量名 = new 数据类型[]{值1,值2,值3…值n}; //（动态初始化）

数组（引用类型）： 数组的下标不要越界使用，否则会报错（编译阶段不报错，运行报异常）

二维数组的定义： 数据类型[][] 数组变量名 = new 数据类型[整数][整数];

数组是引用类型，引用类型有可能发生空指向的问题。 int[] arr=null; //null空指向 引用数据类型可以赋值成 null，这就代表是空指向。 if(arr != null && arr.length != 0)

注意：

1. 使用 arr.length 能够获取到数组的长度，这个操作为成员访问操作符。 2. 使用 [] 按下标取数组元素。需要注意，下标从 0 开始计数。 3. 使用 [] 操作既能读取数据，也能修改数据。 4. 下标访问操作不能超出有效范围 [0, length - 1]，如果超出有效范围，会出现下标越界异常。

遍历数组：

// for 循环遍历数组 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } // 使用 for-each 遍历数组 for (int x : arr) { System.out.println(x); }

创建一个数组（初识JVM内存模型）

创建一个引用只是相当于创建了一个很小的变量，这个变量保存了一个整数，这个整数表示内存中的一个地址。

例如：int[] arr=new int[]{1,2,3}; a) 当创建 new int[]{1,2,3} 的时候，相当于创建了一块内存空间保存三个 int b) 然后执行 int[] arr=new int[]{1,2,3} 相当于有创建了一个 int[] 变量，这个变量是一个引用类型，里面只保存了一个整数（数组的起始内存地址） c) 接下来进行传参相当于 int[] a=arr d) 然后修改 a[0]，此时是根据 0x100 这样的地址找到对应的内存位置，将值改成 100 此时已经将 0x100 地址的数据改成了 100，那么根据实参 arr 来获取数组内容 arr[0]，本质上也是获取 0x100 地址上的数据，也是 100。

总结：所谓的 “引用” 本质上只是存了一个地址。 Java 将数组设定成引用类型，这样后续进行数组参数传参，其实只是将数组的地址传入到函数形参中，这样可以避免对整个数组的拷贝(数组可能比较长，那么拷贝开销就会很大)。

数组作为方法的返回值

// 没有返回值 // 但破坏了原有数组，若不破坏原数组, 就要在方法内部创建一个新的数组，并由方法返回出来 public static void transform(int[] arr) { for (int i = 0; i < arr.length; i++) { arr[i] = arr[i] * 2; } } // 有返回值 // 数组是引用类型，返回时只是将这个数组的首地址返回给函数调用者，没有拷贝数组内容，从而比较高效 public static int[] transform(int[] arr) { int[] ret = new int[arr.length]; for (int i = 0; i < arr.length; i++) { ret[i] = arr[i] * 2; } return ret; }

数组Exercise

// 使用二进制搜索算法搜索指定数组的指定值 (int)Arrays.binarySearch(int[] a,int key) (int)Arrays.binarySearch(int[] a,int fromIndex,int toIndex,int key) // [fromIndex,toIndex) // 复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。 (int[])Arrays.copyOf(int[] original,int newLength) // 将指定数组的指定范围复制到新数组中 (int[])Arrays.copyOfRange(int[] original,int from,int to) // [from,to) // 如果两个指定的int数组彼此相等，则返回 true (boolean)Arrays.equals(int[] a1,int[] a2) // 将val值赋给指定的int数组的每个元素。 (void)Arrays.fill(int[] a,int val) // 将val值赋给指定的int数组的指定范围的每个元素。 (void)Arrays.fill(int[] a,int fromIndex,int toIndex,int val) // 根据指定数组的内容返回哈希码 (int)Arrays.hashCode(int[] a) // 按照数字顺序排列指定的数组 (void)Arrays.parallelSort(int[] a) // 按照数字顺序排列数组的指定范围 (void)Arrays.parallelSort(int[] a，int fromIndex,int toIndex) // 按照数字顺序排列指定的数组 (void)Arrays.sort(int[] a) // 按升序排列数组的指定范围 (void)Arrays.sort(int[] a，int fromIndex,int toIndex) // 返回指定数组的内容的字符串表示形式 (String)Arrays.toString(int[] a)

数组转字符串

int[] arr = {1,2,3,4,5,6}; String newArr = Arrays.toString(arr); System.out.println(newArr); // 执行结果 [1, 2, 3, 4, 5, 6]

数组拷贝

int[] arr = {1,2,3,4,5,6}; int[] newArr = Arrays.copyOf(arr, arr.length); System.out.println("newArr: " + Arrays.toString(newArr));

注意： 相比于 newArr = arr 这样的赋值，copyOf 是将数组进行了深拷贝，即又创建了一个数组对象，拷贝原有数组中的所有元素到新数组中。因此，修改原数组，不会影响到新数组。 最大值

public static int max(int[] arr) { int max = arr[0]; for (int i = 1; i < arr.length; i++) { if (arr[i] > max) { max = arr[i]; } } return max; }

平均值

public static double avg(int[] arr) { int sum = 0; for (int x : arr) { sum += x; } // 结果要用 double 来表示 return (double)sum / (double)arr.length; } // 执行结果 3.5

查找指定元素

public static int find(int[] arr, int toFind) { for (int i = 0; i < arr.length; i++) { if (arr[i] == toFind) { return i; } } return -1; // 表示没有找到 }

有序数组，二分查找

public static int binarySearch(int[] arr, int toFind) { int left = 0; int right = arr.length - 1; while (left <= right) { int mid = (left + right) / 2; if (toFind < arr[mid]) { // 去左侧区间找 right = mid - 1; } else if (toFind > arr[mid]) { // 去右侧区间找 left = mid + 1; } else { // 相等, 说明找到了 return mid; } } // 循环结束, 说明没找到 return -1; }

检查数组有序性

public static boolean isSorted(int[] arr) { for (int i = 0; i < arr.length - 1; i++) { if (arr[i] > arr[i + 1]) { return false; } } return true; }

数组排序

public static void main(String[] args) { int[] arr = {9, 5, 2, 7}; Arrays.sort(arr); System.out.println(Arrays.toString(arr)); }

数组逆序

public static void reverse(int[] arr) { int left = 0; int right = arr.length - 1; while (left < right) { int tmp = arr[left]; arr[left] = arr[right]; arr[right] = tmp; left++; right--; } }

偶数在前，奇数在后

public static void transform(int[] arr) { int left = 0; int right = arr.length - 1; while (left < right) { // 该循环结束, left 就指向了一个奇数 while (left < right && arr[left] % 2 == 0) { left++; } // 该循环结束, right 就指向了一个偶数 while (left < right && arr[right] % 2 != 0) { right--; } // 交换两个位置的元素 int tmp = arr[left]; arr[left] = arr[right]; arr[right] = tmp; } }