vector和arrayList的区别

转载自：http://www.cnblogs.com/plmnko/archive/2010/10/10/1847362.html

AND  http://blog.youkuaiyun.com/tayanxunhua/article/details/10037403

1. Vector & ArrayList 

首先Vector和ArrayList都是基于数组实现的。他们的不同点在于：

1）  Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe)，而ArrayList的方法不是，由于线程的同步必然要影响性能，因此,ArrayList的性能比Vector好。 
2） 当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻(默认情况下如此，事实上Vector的增长量是可控的),而ArrayList只增加50%的大小，这样,ArrayList就有利于节约内存空间。

ArrayList构造方法：

public ArrayList(int initialCapacity)//构造一个具有指定初始容量的空列表。  
public ArrayList()//构造一个初始容量为10的空列表。  
public ArrayList(Collection<? extends E> c)//构造一个包含指定 collection 的元素的列表  

Vector构造方法:

public Vector()//使用指定的初始容量和等于零的容量增量构造一个Vector(增量为0就是默认采用翻倍增量方式)
public Vector(int initialCapacity)//设定初始大小  
public Vector(Collection<? extends E> c)//构造一个包含指定 collection 中的元素的Vector
public Vector(int initialCapacity,int capacityIncrement)//使用指定的初始容量和容量增量构造一个空的Vector

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

2. Hashtable & HashMap 
Hashtable和HashMap它们的性能方面的比较类似 Vector和ArrayList，比如Hashtable的方法是同步的,而HashMap的不是。

3. ArrayList & LinkedList

ArrayList的内部实现是基于内部数组Object[],所以从概念上讲,它更象数组，但LinkedList的内部实现是基于一组连接的记录，所以，它更象一个链表结构，所以，它们在性能上有很大的差别： 
       从上面的分析可知,在ArrayList的前面或中间插入数据时,你必须将其后的所有数据相应的后移,这样必然要花费较多时间，所以,当你的操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能； 而访问链表中的某个元素时,就必须从链表的一端开始沿着连接方向一个一个元素地去查找,直到找到所需的元素为止，所以,当你的操作是在一列数据的前面或中间添加或删除数据，并且按照顺序访问其中的元素时，就应该使用LinkedList了。 
 

如果在编程中，1、2两种情形交替出现,这时,你可以考虑使用List这样的通用接口,而不用关心具体的实现，在具体的情形下,它的性能由具体的实现来保证。

4. 配置集合类的初始大小 
    在Java集合框架中的大部分类的大小是可以随着元素个数的增加而相应的增加的，我们似乎不用关心它的初始大小,但如果我们考虑类的性能问题时,就一定要考虑尽可能地设置好集合对象的初始大小,这将大大提高代码的性能。 
    比如,Hashtable缺省的初始大小为101,载入因子为0.75,即如果其中的元素个数超过75个,它就必须增加大小并重新组织元素，所以,如果你知道在创建一个新的Hashtable对象时就知道元素的确切数目如为110,那么,就应将其初始大小设为110/0.75=148,这样,就可以避免重新组织内存并增加大小。