码迷,mamicode.com
首页 > 其他好文 > 详细

Vector和ArrayList的比较

时间:2016-05-11 21:54:49      阅读:195      评论:0      收藏:0      [点我收藏+]

标签:

今天研究了一下Vector和ArrayList的源码,又加深了对这两个类的理解。

List接口下一共实现了三个类:ArrayList,Vector,LinkedList。LinkedList就不多说了,它一般主要用在保持数据的插入顺序的时候。ArrayList和Vector都是用数组实现的,主要有这么三个区别:

1、Vector是多线程安全的,而ArrayList不是,这个可以从源码中看出,Vector类中的方法很多有synchronized进行修饰,这样就导致了Vector在效率上无法与ArrayList相比;

2、两个都是采用的线性连续空间存储元素,但是当空间不足的时候,两个类的增加方式是不同的,很多网友说Vector增加原来空间的一倍,ArrayList增加原来空间的50%,其实也差不多是这个意思,不过还有一点点问题可以从源码中看出,一会儿从源码中分析。

3、Vector可以设置增长因子,而ArrayList不可以,最开始看这个的时候,我没理解什么是增量因子,不过通过对比一下两个源码理解了这个,先看看两个类的构造方法:

ArrayList有三个构造方法:分别是

 

[java] view plain copy
 技术分享技术分享
  1. public ArrayList(int initialCapacity)//构造一个具有指定初始容量的空列表。  
  2. public ArrayList()//构造一个初始容量为10的空列表。  
  3. public ArrayList(Collection<? extends E> c)//构造一个包含指定 collection 的元素的列表  

 

Vector有四个构造方法:
[java] view plain copy
 技术分享技术分享
  1. public Vector()//使用指定的初始容量和等于零的容量增量构造一个空向量。  
  2. public Vector(int initialCapacity)//构造一个空向量,使其内部数据数组的大小,其标准容量增量为零。  
  3. public Vector(Collection<? extends E> c)//构造一个包含指定 collection 中的元素的向量  
  4. public Vector(int initialCapacity,int capacityIncrement)//使用指定的初始容量和容量增量构造一个空的向量  
Vector比Arraylist多一个构造方法,没错就是public Vector(int initialCapacity,int capacityIncrement)这个构造方法,capacityIncrement就是容量增长,即前面所说的增长因子,ArrayList中是没有的。
再贴出两个类的添加源码分析下(jdk1.7版本):
ArrayList类:
[java] view plain copy
 技术分享技术分享
  1. public boolean add(E e) {  
  2.     ensureCapacityInternal(size + 1);  // Increments modCount!!  
  3.     elementData[size++] = e;  
  4.     return true;  
  5. }  
  6.   
  7. private void ensureCapacityInternal(int minCapacity) {  
  8.     modCount++;  
  9.     // overflow-conscious code  
  10.   
  11.     //如果添加一个元素之后,新容器的大小大于容器的容量,那么就无法存值了,需要扩充空间  
  12.     if (minCapacity - elementData.length > 0)  
  13.   
  14.         grow(minCapacity);  
  15. }  
  16.   
  17. private void grow(int minCapacity) {  
  18.     // overflow-conscious code  
  19.     int oldCapacity = elementData.length;  
  20.     int newCapacity = oldCapacity + (oldCapacity >> 1); //扩充的空间增加原来的50%(即是原来的1.5倍)  
  21.     if (newCapacity - minCapacity < 0) //如果容器扩容之后还是不够,那么干脆直接将minCapacity设为容器的大小  
  22.         newCapacity = minCapacity;  
  23.     if (newCapacity - MAX_ARRAY_SIZE > 0) //如果扩充的容器太大了的话,那么就执行hugeCapacity  
  24.         newCapacity = hugeCapacity(minCapacity);  
  25.     // minCapacity is usually close to size, so this is a win:  
  26.     elementData = Arrays.copyOf(elementData, newCapacity);  
  27. }  
  28.   
  29.  //jdk1.6版本是这样的:  
  30.   
  31.  public void ensureCapacity(int minCapacity) {  
  32.       modCount++;  
  33.       int oldCapacity = elementData.length;  
  34.       if (minCapacity > oldCapacity) {  
  35.            Object oldData[] = elementData;  
  36.            int newCapacity = (oldCapacity * 3) / 2 + 1;  
  37.            if (newCapacity < minCapacity)  
  38.                 newCapacity = minCapacity;  
  39.            // minCapacity is usually close to size, so this is a win:  
  40.            elementData = Arrays.copyOf(elementData, newCapacity);  
  41.       }  
  42.  }  


Vector类:
[java] view plain copy
 技术分享技术分享
  1.  public synchronized boolean add(E e) {  
  2.      modCount++;  
  3.      ensureCapacityHelper(elementCount + 1);  
  4.      elementData[elementCount++] = e;  
  5.      return true;  
  6.  }  
  7.   
  8.  private void ensureCapacityHelper(int minCapacity) {  
  9.      // overflow-conscious code  
  10.      if (minCapacity - elementData.length > 0)  
  11.          grow(minCapacity);  
  12.  }  
  13.   
  14.  private void grow(int minCapacity) {  
  15.      // overflow-conscious code  
  16.      int oldCapacity = elementData.length;  
  17.      int newCapacity = oldCapacity + ((capacityIncrement > 0) ?  
  18.                                       capacityIncrement : oldCapacity);  
  19.   
  20.      /** 
  21.  
  22.      这个扩容需要做个判断:如果容量增量初始化的不是0,即使用的public Vector(int initialCapacity,int capacityIncrement) 
  23.  
  24.      构造方法进行的初始化,那么扩容的容量是(oldCapacity+capacityIncrement),就是原来的容量加上容量增量的值; 
  25.  
  26.      如果没有设置容量增量,那么扩容后的容量就是(oldCapacity+oldCapacity),就是原来容量的二倍。 
  27.  
  28.      **/  
  29.   
  30.      if (newCapacity - minCapacity < 0)  
  31.          newCapacity = minCapacity;  
  32.      if (newCapacity - MAX_ARRAY_SIZE > 0)  
  33.          newCapacity = hugeCapacity(minCapacity);  
  34.      elementData = Arrays.copyOf(elementData, newCapacity);  
  35.  }  
  36.   
  37. //jdk1.6版本是这样的:       
  38. private void ensureCapacityHelper(int minCapacity) {  
  39.        int oldCapacity = elementData.length;  
  40.        if (minCapacity > oldCapacity) {  
  41.             Object[] oldData = elementData;  
  42.             int newCapacity = (capacityIncrement > 0) ? (oldCapacity + capacityIncrement)  
  43.                       : (oldCapacity * 2);//方式与jdk1.7一样  
  44.             if (newCapacity < minCapacity) {  
  45.                  newCapacity = minCapacity;  
  46.             }  
  47.             elementData = Arrays.copyOf(elementData, newCapacity);  
  48.        }  
  49.   }  
来源:http://blog.csdn.net/tayanxunhua/article/details/10037403

Vector和ArrayList的比较

标签:

原文地址:http://www.cnblogs.com/lwhcs/p/5483596.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!