Vector和ArrayList异同

 从图中可以看出,Vector和ArrayList者都实现了List接口.所有使用方式也很相似,主要区别在于因为实现方式的不同,所以对不同的操作具有不同的效率。

首先我们来看看Vector和ArrayList的相同点：

1. 这两个类都实现了List接口（List接口继承了Collection接口），他们都是有序集合，即存储在这两个集合中的元素的位置都是有顺序的，相当于一种动态的数组，我们以后可以按位置索引号取出某个元素

2. 并且其中的数据是允许重复的，这是HashSet之类的集合的最大不同处，HashSet之类的集合不可以按索引号去检索其中的元素，也不允许有重复的元素

3. 都有初始化的值

Vector和ArrayList的不同点:

1、不同的在于序列化方面：ArrayList比Vector安全，

在ArrayList集合中：

//采用elementData数组来存储集合元素

private transient  Object[] elementData;

在Vector集合中：

//采用elementData数组来保存集合元素

private Object[] elementData;

从源码可以看出，ArrayList提供的writeObject和readObject方法来实现定制序列化，而Vector只是提供了writeObject方法，并没有完全实现定制序列化。

2.ArrayList和Vector都采用线性连续存储空间，当存储空间不足的时候，ArrayList默认增加为原来的50%，Vector默认增加为原来的一倍；

ArrayList默认增加为原来的50%:

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默认增加为原来的一倍：

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);  
  }  

3：vector可以设置capacityIncrement，而ArrayList不可以，从字面理解就是capacity容量，Increment增加，容量增长的参数。

源码分析： 
首先看看构造器： 

ArrayList：三个

/**
     * Constructs an empty list with an initial capacity of ten.
     * 构造一个默认初始容量为10的list 
     */
    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }

    /**
     * 构造一个指定默认长度的list initialCapacity 不能小于0;
     * Constructs an empty list with the specified initial capacity.
     *
     * @param  initialCapacity  the initial capacity of the list
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     */
    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }




 /**  构造一个包含collection 元素的list
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    public ArrayList(Collection<? extends E> c) {
      ...
    }

Vector：四个:

//构造一个指定默认长度的list
  public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }
 //构造一个默认初始容量为10的list 
  public Vector() {
        this(10);
    }
  //构造一个包含collection 元素的list
  public Vector(Collection<? extends E> c) {
        ...
    }
//区别在于可以设置capacityIncrement
 public Vector(int initialCapacity, int capacityIncrement) {
        super();
       ...
    }

vector多了一个public Vector(int initialCapacity, int capacityIncrement)构造器，可以设置容量增长，arraylist是没有的。

主要添加源码分析

ArrayList类：

 public boolean add(E e) {  
        ensureCapacityInternal(size + 1);  // Increments modCount!!  
        elementData[size++] = e;  
        return true;  
    }  

    private void ensureCapacityInternal(int minCapacity) {  
        modCount++;  
        // overflow-conscious code  

        //如果添加一个元素之后，新容器的大小大于容器的容量，那么就无法存值了，需要扩充空间  
        if (minCapacity - elementData.length > 0)  

            grow(minCapacity);  
    }  

    private void grow(int minCapacity) {  
        // overflow-conscious code  
        int oldCapacity = elementData.length;  
        int newCapacity = oldCapacity + (oldCapacity >> 1); //扩充的空间增加原来的50%（即是原来的1.5倍）  
        if (newCapacity - minCapacity < 0) //如果容器扩容之后还是不够，那么干脆直接将minCapacity设为容器的大小  
            newCapacity = minCapacity;  
        if (newCapacity - MAX_ARRAY_SIZE > 0) //如果扩充的容器太大了的话，那么就执行hugeCapacity  
            newCapacity = hugeCapacity(minCapacity);  
        // minCapacity is usually close to size, so this is a win:  
        elementData = Arrays.copyOf(elementData, newCapacity);  
    }  

Vector类：

  public synchronized boolean add(E e) {  
         modCount++;  
         ensureCapacityHelper(elementCount + 1);  
         elementData[elementCount++] = e;  
         return true;  
     }  

     private void ensureCapacityHelper(int minCapacity) {  
         // overflow-conscious code  
         if (minCapacity - elementData.length > 0)  
             grow(minCapacity);  
     }  

     private void grow(int minCapacity) {  
         // overflow-conscious code  
         int oldCapacity = elementData.length;  
         int newCapacity = oldCapacity + ((capacityIncrement > 0) ?  
                                          capacityIncrement : oldCapacity);  

         /** 

         这个扩容需要做个判断：如果容量增量初始化的不是0，即使用的public Vector(int initialCapacity,int capacityIncrement) 

         构造方法进行的初始化，那么扩容的容量是(oldCapacity+capacityIncrement)，就是原来的容量加上容量增量的值； 

         如果没有设置容量增量，那么扩容后的容量就是(oldCapacity+oldCapacity)，就是原来容量的二倍。 

         **/  

         if (newCapacity - minCapacity < 0)  
             newCapacity = minCapacity;  
         if (newCapacity - MAX_ARRAY_SIZE > 0)  
             newCapacity = hugeCapacity(minCapacity);  
         elementData = Arrays.copyOf(elementData, newCapacity);  
     }  

4：从存取操作的效率来看

在删除数据操作中linklist最快；

在存数据操作中linklist最快；

在取数据操作中 ArrayList最快；