ArrayList VS Vector(ArrayList和Vector的区别)_面试的时候经常出现

数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的 

这个我们可以看看他们的源码就可以知道：

ArrayList的size()方法：

/**
     * Returns the number of elements in this list.
     *
     * @return the number of elements in this list
     */
    public int size() {
        return size;
    }

Vector的size()方法：

/**
     * Returns the number of components in this vector.
     *
     * @return  the number of components in this vector
     */
    public synchronized int size() {
        return elementCount;
    }

其实Vector的其他很多方法都是同步的：

/**
     * Sets the size of this vector. If the new size is greater than the
     * current size, new {@code null} items are added to the end of
     * the vector. If the new size is less than the current size, all
     * components at index {@code newSize} and greater are discarded.
     *
     * @param  newSize   the new size of this vector
     * @throws ArrayIndexOutOfBoundsException if the new size is negative
     */
    public synchronized void setSize(int newSize) {
        modCount++;
        if (newSize > elementCount) {
            ensureCapacityHelper(newSize);
        } else {
            for (int i = newSize ; i < elementCount ; i++) {
                elementData[i] = null;
            }
        }
        elementCount = newSize;
    }

    /**
     * Returns the current capacity of this vector.
     *
     * @return  the current capacity (the length of its internal
     *          data array, kept in the field {@code elementData}
     *          of this vector)
     */
    public synchronized int capacity() {
        return elementData.length;
    }

    /**
     * Returns the number of components in this vector.
     *
     * @return  the number of components in this vector
     */
    public synchronized int size() {
        return elementCount;
    }

    /**
     * Tests if this vector has no components.
     *
     * @return  {@code true} if and only if this vector has
     *          no components, that is, its size is zero;
     *          {@code false} otherwise.
     */
    public synchronized boolean isEmpty() {
        return elementCount == 0;
    }

那现在我们应该设计一个方案来研究我们的这些结论的正确性！！

下面给出ArrayList线程不安全证明方案：

/**
 * 
 */
package com.b510;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @date 2013-5-2
 * @author xhw
 * 
 */
public class HongtenArrayList implements Runnable {
    //线程不安全
     List<String> list = new ArrayList<String>(1);
    //线程安全
    //List<String> list = Collections.synchronizedList(new ArrayList<String>());
    public void run() {
        try {
            Thread.sleep((int) (Math.random() * 2));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
        list.add(Thread.currentThread().getName());
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadGroup group = new ThreadGroup("hongtenGroup");
        HongtenArrayList t = new HongtenArrayList();
        for (int i = 0; i < 10000; i++) {
            Thread th = new Thread(group, t, String.valueOf(i));
            th.start();
        }
        while (group.activeCount() > 0) {
            Thread.sleep(10);
        }
        System.out.println("result=============");
        //如果线程安全，那么结果是10000，如果线程不安全，则结果不可预测
        System.out.println(t.list.size()); 
    }

}

下面贴出部分运行结果：

线程不安全：

当然线程安全下面会出现：(运行结果都是10000)

9982
9988
9990
9979
9981
9977
9965
9971
9848
9846
9989
9993
9991
9678
9995
9992
9998
9994
9996
9997
9999
result=============
10000

对于增长，我们可以看看ArrayList的源码：

ArrayList:grow()

/**
     * Increases the capacity to ensure that it can hold at least the
     * number of elements specified by the minimum capacity argument.
     *
     * @param minCapacity the desired minimum capacity
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

Vector:grow()

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }