Java中数组的实际经典案例
数组不仅是Java中学习的重点，也是数据结构与算法中学习的重点，我们不仅要熟悉它，也要懂得运用它。
1. 数组的拷贝
数组的拷贝分为两种，一种是对值得拷贝，一种是对地址的拷贝。
上一章中我们已经知道了数组是储存在堆上的，在栈上new出来的只是一个局部变量，用于储存堆山的地址。
上代码：
import java.util.Arrays;
public class demo {
public static int[] copyArray(int[] arr){
int[] copyArr = arr;
return copyArr;
}
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
System.out.println(Arrays.toString(copyArray(arr)));
}
}
两个变量同时存储同一个地址。
import java.util.Arrays;
public class demo {
public static int[] copyArray(int[] arr){
int[] copyArr = new int[arr.length];
copyArr = arr;
return copyArr;
}
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
System.out.println(Arrays.toString(copyArray(arr)));
}
}
总结：只要是new出来的都是一个新地址。
2. 查找数组中指定元素(二分查找)
啥叫有序数组?有序分为 " 升序 " 和 " 降序 "如 1 2 3 4 , 依次递增即为升序 .如 4 3 2 1 , 依次递减即为降序
那么顺序查找可不可以呢？
当然是可行的，但是如果数组非常大，我们需要找的值在后面，那就会造成速度非常慢，效果非常差。
那可以选择用二分查找（也可以选择其他 更快更有效的算法）。
思路分析：
以升序数组为例 , 二分查找的思路是先取中间位置的元素 , 然后使用待查找元素与数组中间元素进行比较：如果相等，即找到了返回该元素在数组中的下标如果小于，以类似方式到数组左半侧查找如果大于，以类似方式到数组右半侧查找
第三次查找：依旧和前两次查找一样。
直到找到这个目标元素。
public class demo {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
System.out.println(binarySearch(arr, 6));
}
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;
}
}
这样三次就可以找到目标元素了。
3. 数组排序(冒泡排序)
假设排升序：1. 将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素 就在数组的末尾2. 依次从上上述过程，直到数组中所有的元素都排列好
上代码：
import java.util.Arrays;
public class demo {
public static void main(String[] args) {
int[] arr = {9, 5, 2, 6, 8, 12, 7};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 1; j < arr.length-i; j++) {
if (arr[j-1] > arr[j]) {
int tmp = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = tmp;
}
}
} // end for
} // end bubbleSort
}
当然了，冒泡排序是一种比较低效的的算法，我们Java提供了更高效的算法
public static void main(String[] args) {
int[] arr = {9, 5, 2, 7};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}
4. 转轮数组
最简单的解法：使用额外的数组
我们可以使用额外的数组来将每个元素放至正确的位置。用 nn 表示数组的长度，我们遍历原数组，将原数组下标为 ii 的元素放至新数组下标为 (i+k)\bmod n(i+k)modn 的位置，最后将新数组拷贝至原数组即可。
import java.util.Arrays;
public class demo {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7};
rotate(arr,3);
System.out.println(Arrays.toString(arr));
}
public static void rotate(int[] nums, int k) {
int n = nums.length;
int[] newArr = new int[n];
for (int i = 0; i < n; ++i) {
newArr[(i + k) % n] = nums[i];
}
System.arraycopy(newArr, 0, nums, 0, n);
}
}
也有其他的方法：数组翻转
思路：
三步翻转法，其实轮转数组类似于之前介绍过的倒置字符串，即整体先翻转，左半部分翻转，右半部分翻转，就能得到最终结果。假设数组 nums 为 1、2、3、4、5，轮转 3 次，先整体翻转(0 ~ numsSize - 1)，数组为 5、4、3、2、1，再翻转左半部分(0 ~ k - 1)，数组为 3、4、5、2、1，最后再翻转右半部分(k ~ numsSize - 1)，数组为 3、4、5、1、2，结果出来了，这就是 三步翻转法 的奇妙解法
图示：
import java.util.Arrays;
public class demo {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7};
rotate(arr,3);
System.out.println(Arrays.toString(arr));
}
public static void rotate(int[] nums, int k) {
k %= nums.length;
reverse(nums, 0, nums.length - 1);
reverse(nums, 0, k - 1);
reverse(nums, k, nums.length - 1);
}
public static void reverse(int[] nums, int start, int end) {
while (start < end) {
int temp = nums[start];
nums[start] = nums[end];
nums[end] = temp;
start += 1;
end -= 1;
}
}
}
当然力扣官方还有一种解法：
我把链接放在这里：旋转数组 - 轮转数组 - 力扣（LeetCode） 感兴趣的可以去了解一下。
数组是个非常重要的点，以后刷题会经常用到数组，这里先介绍一些，后面遇到有趣的题目我还会在写进我的博客里。