基础知识

数组是具有相同类型的数据的集合，也就是说数组的所有元素的类型都是相同的，在所有的数据结构中，数组算是最常见也是最简单的一种数据结构，我们最常见的也就是一维数组，当然还有二维，三维……，数组需要先声明才能使用，数组的大小一旦确定就不可以在变了。比如我们声明一个长度为10的数组

1int[] array = new int[10];

数组的下标是从0开始的，比如上面数组的第一个元素是array[0]，最后一个元素是array[9]。

我们还可以在声明的时候直接对他进行初始化，比如

1int[] array = new int[]{1, 2, 3};

上面我们声明了一个长度为3的数组。

源码分析

操作数组的类我们常见的估计也就是ArrayList了，他对数组的操作非常简单，所有的数据都会存放到这个数组中

1transient Object[] elementData;

我们来看一下他常见的几个方法，首先是get方法

1public E get(int index) {2    if (index >= size)3        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));45    return (E) elementData[index];6}

首先判断是否越界，如果越界直接抛异常，否则就根据他的下标从数组中直接返回，在看一下他的set方法

1public E set(int index, E element) {2    if (index >= size)3        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));45    E oldValue = (E) elementData[index];6    elementData[index] = element;7    return oldValue;8}

和get方法一样，也是先判断是否越界，然后再操作，代码比较简单，我们再来看一个add方法

 1public void add(int index, E element) { 2    if (index > size || index 0) 3        throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); 4 5    ensureCapacityInternal(size + 1);  // Increments modCount!! 6    System.arraycopy(elementData, index, elementData, index + 1, 7                     size - index); 8    elementData[index] = element; 9    size++;10}

这里也是先判断是否越界，然后再判断是否需要扩容，最后在操作，接着我们来看一下ensureCapacityInternal方法

 1private void ensureCapacityInternal(int minCapacity) { 2    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { 3        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); 4    } 5 6    ensureExplicitCapacity(minCapacity); 7} 8 9private void ensureExplicitCapacity(int minCapacity) {10    modCount++;1112    // overflow-conscious code13    if (minCapacity - elementData.length > 0)14        grow(minCapacity);15}

他的默认初始化大小是10

1private static final int DEFAULT_CAPACITY = 10;

上面代码第13行，如果我们需要的空间大于数组长度的时候，说明数组不够用了，要进行扩容，就会执行下面的grow方法，我们来看一下grow方法的代码

 1private void grow(int minCapacity) { 2    // overflow-conscious code 3    int oldCapacity = elementData.length; 4    int newCapacity = oldCapacity + (oldCapacity >> 1); 5    if (newCapacity - minCapacity 0) 6        newCapacity = minCapacity; 7    if (newCapacity - MAX_ARRAY_SIZE > 0) 8        newCapacity = hugeCapacity(minCapacity); 9    // minCapacity is usually close to size, so this is a win:10    elementData = Arrays.copyOf(elementData, newCapacity);11}

代码也比较简单，扩容的时候在第4行还会增加一半的大小，比如原来数组大小是10，第一次扩容后会是15。在ArrayList中无论使用add还是remove都会使用这样一个方法

1        System.arraycopy(elementData, index+1, elementData, index,2                         numMoved);

这说明对数组的查找是比较方便的，但对数组的增删就没那么方便了，因为数组是一块连续的内存空间，如果在前面增加和删除，都会导致后面元素位置的变动。

ArraList是线程不安全，如果使用线程安全的可以用Vector，还有一个线程安全的类

CopyOnWriteArrayList，他只在add和remove的时候，也就是修改数据的时候会先synchronized，在get的时候没有，我们来看一下代码

1private E get(Object[] a, int index) {2    return (E) a[index];3}

我们再来看一下他的add方法

 1public boolean add(E e) { 2    synchronized (lock) { 3        Object[] elements = getArray(); 4        int len = elements.length; 5        Object[] newElements = Arrays.copyOf(elements, len + 1); 6        newElements[len] = e; 7        setArray(newElements); 8        return true; 9    }10}

他不像ArrayList每次扩容的时候，size都会增加一半，他是每次add一个元素的时候size只会加1，同理remove的时候size只会减1。

后话

常见的数据结构种类也不是很多，比如，数组，链表，队列，栈，树，图，等，还有数组和链表结合的，比如HashMap。但每一种又会有很多的分类，比如链表有单向的，双向的，环形的，队列又有一般的队列和双端队列，树又分为二叉树，AVL树，红黑树，B+树，2-3树，哈夫曼树，字典树等等。如果细分下去，还是比较多的，今天讲的数组是最简单的一种数据结构，基本上也没什么可说的，剩下的那些数据结构后续都会一一分析。