java基础复习七：数组的声明与扩容

如何声明数组，有几种方式，面试的时候经常被问道，每次都是临时记一下，也没有认真对待这个问题，现在复习一下。

数组的声明

最常用的声明方式

代码：

public static void main(String[] args) {

        String[] strArr = new String[10];
        strArr[10] = "145";
    }

这是我最常用的声明方式，大多数使用数组时，都能确定数组中元素的个数。
这种写法，只是初始化了容量，但是具体的元素需要另外赋值。

但是一旦超过指定的容量，就会报错，上面代码执行就会报下面这个错误：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10
    at test.TestArray.main(TestArray.java:14)

第二种声明方式

代码：

public static void main(String[] args) {

        String[] strArr = new String[]{"0", "1"};

        strArr[10] = "145";
    }

这种写法不明显制定数组的容量，但是直接写出了数组拥有的元素，只有两个，也就是说数组容量就是2，如果执行上面的代码，也会报错：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10
    at test.TestArray.main(TestArray.java:14)

第三种写法

代码：

 public static void main(String[] args) {

        String[] strArr = {"0", "1"};

        strArr[10] = "145";
    }

这种写法也是直接说明了数组的元素，同样无法超出容量范围。

总结：
以上三种写发，实际上是都必须指定数组的长度，超出长度就会报错。

扩容

集合和队列都有使用数组的实现，这些实现是允许一直添加的（直到溢出为止），这些实现都不是固定的长度的数组可以支持的，必须实现数组的扩容，现在就看一下数组如何扩容。

任何一个数组长度都是固定的，所谓扩容就是定义一个新的数组，把原来数组的元素复制到新的数组中。
因此，可以根据这种思想自己实现扩容方法，也可以使用Java提供的方法。

Java提供了两种方法：
– System.arraycopy()
– Arrays.copyOf()

先看第一种方法System.arraycopy()
源码：

* @param      src      the source array.
     * @param      srcPos   starting position in the source array.
     * @param      dest     the destination array.
     * @param      destPos  starting position in the destination data.
     * @param      length   the number of array elements to be copied.
     * @exception  IndexOutOfBoundsException  if copying would cause
     *               access of data outside array bounds.
     * @exception  ArrayStoreException  if an element in the <code>src</code>
     *               array could not be stored into the <code>dest</code> array
     *               because of a type mismatch.
     * @exception  NullPointerException if either <code>src</code> or
     *               <code>dest</code> is <code>null</code>.
     */
    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

这是一个native方法，看不到实现，参数的注释非常的清楚，现在使用这个方法实现一个数组扩容。

测试代码：

public static void main(String[] args) {

        String[] strArr = {"0", "1", "2"};

        String[] newArr = new String[10];
        System.arraycopy(strArr, 0, newArr, 3, 3);
        strArr = newArr;
        for (String s : strArr) {
            System.out.println("元素：" + s);
        }
    }

输出结果：

元素：null
元素：null
元素：null
元素：0
元素：1
元素：2
元素：null
元素：null
元素：null
元素：null

可以看到现在strArr的长度是10，原来的元素复制到了3-5位上。

第二种实现方式Arrays.copyOf()：
代码：

public static void main(String[] args) {

        String[] strArr = {"0", "1", "2"};

        //String[] newArr = new String[10];
        //System.arraycopy(strArr, 0, newArr, 3, 3);
        //strArr = newArr;
        strArr = Arrays.copyOf(strArr, strArr.length + 7);
        for (String s : strArr) {
            System.out.println("元素：" + s);
        }
    }

输出：

元素：0
元素：1
元素：2
元素：null
元素：null
元素：null
元素：null
元素：null
元素：null
元素：null

这种扩容方式，无法指定复制开始的位置，也无法指定复制到的位置；

源码：

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

可以看到，这种扩容方式实际上也是使用System.arraycopy方法，只不过位置默认为0。

总结

1、数组的长度是固定的；
2、数组的扩容实际上是新建一个数组；