数组基础

前提

算法中大多数用到数组，理解数组是学习算法的前提。下面用小白的角度重新记录一下数组相关的知识，包括声明、使用等等，不涉及JVM层面。主要介绍基本类型整型的数组，其他类型类同。参考资料：

• Java数组详解

数组简介

数组表示同一种类型数据的集合。其实数组就是一个容器。运算的时候有很多数据参与运算，那么首先需要做的是什么。不是如何运算而是如何保存这些数据以便于后期的运算，那么数组就是一种用于存储数据的方式，能存数据的地方我们称之为容器，容器里装的东西就是数组的元素， 数组可以装任意类型的数据，虽然可以装任意类型的数据，但是定义好的数组只能装一种元素，也就是数组一旦定义，那么里边存储的数据类型也就确定了。

数组声明

一维数组声明

声明格式一：元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

例如：int[] arr = new int[5];

声明格式二：元素类型[] 数组名 = new 元素类型[]{元素1,元素2,…元素n};

例如：int[] arr = new int[]{3,5,1,7};

声明格式三：元素类型[] 数组名 = {元素1,元素2,…元素n};

例如：int[] arr = {3,5,1,7};

多维数组声明

例如二维数组的声明跟一维数组大致相同：

元素类型[][] 数组名 = new 元素类型[第一维数组的长度][第二维数组的长度];

小结

其实可以这样类比：一维数组类比为一维坐标轴，二维数组类比为二维坐标轴，三维数组类比为三维坐标轴...。

注意事项和常见异常

数组下标从0开始

数组下标从0开始，也就是第一个元素的索引值为0，而索引值为1是第二个元素的下标。

int[] arr = new int[]{3,5,1,7};
-->arr[0]值为3
-->arr[1]值为5

空指针异常

一般出现NPE(NullPointerException)是因为访问了null对象的属性或者是调用了null对象的方法。例如：

int[] x = { 1, 2, 3 };
x = null;
System.out.println(x[1]);
// java.lang.NullPointerException

索引值越界异常

一般出现ArrayIndexOutOfBoundsException(俗称数组越界异常)是因为访问了不存在的数组索引值。例如：

int[] x = { 1, 2, 3 };
System.out.println(x[3]);
//java.lang.ArrayIndexOutOfBoundsException

无法实例化泛型数组

这个和Java的泛型机制相关，这里不深入展开。也就是说数组在实例化的时候类型必须是具体的，不能带有泛型参数。但是注意，泛型数组可以作为变量。例如：

T[] t = new T[5]; //编译无法通过

//泛型数组可以作为变量
public <T> void sort(T[] ts){
    //todo
}

数组常用的操作

元素遍历

直接用for循环或者foreach即可。

    private static void traverse(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

元素插入

新元素通过下标插入，如果确定不会越界的话，需要把数组扩容，容量加1，下标所有位置后面的所有元素都要后移一个位置。

    private static int[] insert(int index, int value, int[] array) {
        //先判断是否越界
        if (index < 0 || index > array.length) {
            throw new IllegalArgumentException("index");
        }
        int[] newArray = new int[array.length + 1];
        //index下标前面的元素复制
        for (int i = 0; i < index; i++) {
            newArray[i] = array[i];
        }
        //index下标元素赋值
        newArray[index] = value;
        //index下标后面的元素后移动一个位置
        for (int k = index + 1; k < newArray.length; k++) {
            newArray[k] = array[k - 1];
        }
        return newArray;
    }

当然，可以通过数组的拷贝API简化如下：

    private static int[] insert(int[] array, int value, int index) {
        int length = array.length;
        int[] newArray = new int[length + 1];
        System.arraycopy(array, 0, newArray, 0, index);
        newArray[index] = value;
        System.arraycopy(array, index, newArray, index + 1, length - index);
        return newArray;
    }

元素替换

元素替换比元素插入简单，如果确定不会越界的话直接替换掉对应下标的元素值即可。

    private static int[] replace(int index, int value, int[] array){
        //先判断是否越界
        if (index < 0 || index >= array.length) {
            throw new IllegalArgumentException("index");
        }
        array[index] = value;
        return array;
    }

元素移除

元素移除可以看作是元素插入的逆向操作，如果确定不会越界的话，需要把数组减容，容量减1，下标所有位置后面的所有元素都要前移一个位置。

    private static int[] remove(int index, int[] array) {
        if (index < 0 || index >= array.length) {
            throw new IllegalArgumentException("index");
        }
        int[] newArray = new int[array.length - 1];
        for (int i = 0; i < index; i++) {
            newArray[i] = array[i];
        }
        for (int k = index + 1; k <= newArray.length; k++) {
            newArray[k - 1] = array[k];
        }
        return newArray;
    }

或者使用数组拷贝的API：

    private static int[] remove(int index, int[] array) {
        if (index < 0 || index >= array.length) {
            throw new IllegalArgumentException("index");
        }
        int length = array.length;
        int[] newArray = new int[length - 1];
        System.arraycopy(array, 0, newArray, 0, index - 1);
        System.arraycopy(array, index, newArray, index - 1, length - index);
        return newArray;
    }

元素查找

通过下标查找看起来有点多余：

    private static int search(int index, int[] array){
        if (index < 0 || index >= array.length) {
            throw new IllegalArgumentException("index");
        }
        return array[index];
    }

有序数组操作

有序数组的元素插入、替换、移除是不需要依赖传入下标值，因为可以通过元素的比较得到需要操作的元素下标，有序数组的元素的查找可以使用二分查找以提高效率。

   private static void print(int[] array) {
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < array.length; i++) {
            builder.append(array[i]).append(",");
        }
        System.out.println(builder.substring(0, builder.lastIndexOf(",")));
    }

    private static int[] insert(int target, int[] array) {
        int length = array.length;
        int index = length;
        //先判断新元素的下标
        for (int i = 0; i < length; i++) {
            if (target < array[i]) {
                index = i;
                break;
            }
        }
        int[] newArray = new int[length + 1];
        //下标前面的元素复制
        for (int j = 0; j < index; j++) {
            newArray[j] = array[j];
        }
        newArray[index] = target;
        //下标后面的元素后移
        for (int k = index + 1; k < newArray.length; k++) {
            newArray[k] = array[k - 1];
        }
        return newArray;
    }

    private static int[] replace(int target, int[] array) {
        int length = array.length;
        int index = length;
        //先判断新元素的下标
        for (int i = 0; i < length; i++) {
            if (target < array[i]) {
                index = i;
                break;
            }
        }
        //修正差距,选择差距最小的值进行替换
        if (array[index] - target > target - array[index - 1]) {
            index = index - 1;
        }
        array[index] = target;
        return array;
    }

    private static int[] remove(int target, int[] array) {
        int length = array.length;
        int index = length;
        //先判断新元素的下标
        for (int i = 0; i < length; i++) {
            if (target < array[i]) {
                index = i;
                break;
            }
        }
        //修正差距,选择差距最小的值进行替换
        if (array[index] - target > target - array[index - 1]) {
            index = index - 1;
        }
        int[] newArray = new int[array.length - 1];
        for (int i = 0; i < index; i++) {
            newArray[i] = array[i];
        }
        for (int k = index + 1; k <= newArray.length; k++) {
            newArray[k - 1] = array[k];
        }
        return newArray;
    }

    private static int binarySearch(int target, int[] array) {
        int lower = 0;
        int upper = array.length - 1;
        while (lower <= upper) {
            int mid = (lower + upper) / 2;
            int midValue = array[mid];
            if (midValue < target) {
                lower = mid + 1;
            } else if (midValue > target) {
                upper = mid - 1;
            } else {
                return mid;
            }
        }
        return -(lower + 1);
    }

对于二分查找，有现成的工具方法：java.util.Arrays#binarySearch，上面的二分搜索方法也是直接参考里面的实现。Arrays.binarySearch方法使用前，需要对数组排序，才能定位值插入位置，因为binarySearch采用二分搜索法。可以借鉴这个思路，处理非有序数组的时候，先使用java.util.Arrays#sort对数组进行排序，再使用java.util.Arrays#binarySearch。不过如果排序的耗时过多会得不偿失，这个可以自己衡量一下。在空闲的时候看了下java.util.Arrays里面的排序算法，发现了java.util.DualPivotQuicksort和java.util.TimSort才深知大神的厉害和自己的渺小。

小结

其实一直纠结算法学习怎么入手，到底看Java的实现还是C的实现。后来发现纠结是浪费时间，索性先看Java再重新学习一下C。推荐的资料如下(现在还没有看，打算一本一本地啃)：

• 数据结构于算法分析-Java语言描述(或者C语言描述)
• Jdk中的两个类java.util.DualPivotQuicksort和java.util.TimSort
• The Algorithm Design Manual
• Algorithms 4th

主要推送的资料来自一个大神的书单：我的算法学习之路。

能不能坚持下去谁也不知道，共勉。

（本文完）

技术公众号（《Throwable文摘》），不定期推送笔者原创技术文章（绝不抄袭或者转载）：

娱乐公众号（《天天沙雕》），甄选奇趣沙雕图文和视频不定期推送，缓解生活工作压力：