源码分析三(Vector与ArrayList的区别)

前面讨论过ArrayList与LinkedList的区别，ArrayList的底层数据结构是数组Object[]，而LinkedList底层维护

的是一个链表Entry,所以对于查询，肯定是ArrayList的效率高，但是对于删除和插入则是LinedList效率高。

现在我们再来看看Vector与ArrayList的区别，直接上源码，ArrayList源码：

1：扩容方面，ArrayList扩容扩原来容量的3/2+1，而Vector扩容为原来容量的2倍

 public void ensureCapacity(int minCapacity) {
     modCount++;
　　　　//容器中元素的数量
     int oldCapacity = elementData.length;
     if (minCapacity > oldCapacity) {
         Object oldData[] = elementData;
　　　　　　//新的容量
         int newCapacity = (oldCapacity * 3)/2 + 1;
             if (newCapacity < minCapacity)
         newCapacity = minCapacity;
             // minCapacity is usually close to size, so this is a win:
             elementData = Arrays.copyOf(elementData, newCapacity);
     }
     }

2：Vector源码

  private void ensureCapacityHelper(int minCapacity) {
     int oldCapacity = elementData.length;
     if (minCapacity > oldCapacity) {
         Object[] oldData = elementData;
         int newCapacity = (capacityIncrement > 0) ?
         (oldCapacity + capacityIncrement) : (oldCapacity * 2);
             if (newCapacity < minCapacity) {
         newCapacity = minCapacity;
         }
             elementData = Arrays.copyOf(elementData, newCapacity);
     }
     }

默认创建的Vector对象new Vector(); 默认

capacityIncrement = 0

  public Vector() {
     this(10);
     }

调一个参数的构造方法：

  public Vector(int initialCapacity) {
     this(initialCapacity, 0);
     }

默认增长容量为0

调用两个参数的构造方法：

   public Vector(int initialCapacity, int capacityIncrement) {
     super();
         if (initialCapacity < 0)
             throw new IllegalArgumentException("Illegal Capacity: "+
                                                initialCapacity);
     this.elementData = new Object[initialCapacity];
     this.capacityIncrement = capacityIncrement;
     }

所以

 int newCapacity = (capacityIncrement > 0) ?
         (oldCapacity + capacityIncrement) : (oldCapacity * 2);

新的容量扩展到原来的2倍。

再来看它们的另外一个区别，ArrayList类中的方法都是没有synchronized修饰的，所以都是非线程安全的，

获取集合中元素数量：

  public int size() {
     return size;
     }

判断集合是否为空：

  public boolean isEmpty() {
     return size == 0;
     }

   public boolean contains(Object o) {
     return indexOf(o) >= 0;
     }

。。。。。

再来看看Vector类，方法都是由synchronized修饰，所以是线程安全的，万事都是有利有弊，线程安全的处理数据效率会低，而线程非安全的处理

数据效率相对高一些：

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

 public synchronized int capacity() {
     return elementData.length;
     }

   public synchronized int size() {
     return elementCount;
     }

   public synchronized boolean isEmpty() {
     return elementCount == 0;
     }

。。。。。。