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. 数组排序(冒泡排序) 

上代码：

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） 感兴趣的可以去了解一下。

 数组是个非常重要的点，以后刷题会经常用到数组，这里先介绍一些，后面遇到有趣的题目我还会在写进我的博客里。