Vector底层结构和源码剖析及ArrayList和Vector比较

Vector``底层结构和源码剖析

Vector的基本介绍：

继承关系图和构造器

构造器

Constructor and Description
Vector() 构造一个空向量，使其内部数据数组的大小为 10 ，标准容量增量为零。
Vector(Collection<? extends E> c) 构造一个包含指定集合元素的向量，按照集合的迭代器返回的顺序。
Vector(int initialCapacity) 构造具有指定初始容量并且其容量增量等于零的空向量。
Vector(int initialCapacity, int capacityIncrement) 构造具有指定的初始容量和容量增量的空向量。

常用方法

boolean	add(E e) 将指定的元素追加到此Vector的末尾。
void	add(int index, E element) 在此Vector中的指定位置插入指定的元素。
boolean	addAll(Collection<? extends E> c) 将指定集合中的所有元素追加到该向量的末尾，按照它们由指定集合的迭代器返回的顺序。
boolean	addAll(int index, Collection<? extends E> c) 将指定集合中的所有元素插入到此向量中的指定位置。
void	addElement(E obj) 将指定的组件添加到此向量的末尾，将其大小增加1。
int	capacity() 返回此向量的当前容量。
void	clear() 从此Vector中删除所有元素。

boolean	contains(Object o) 如果此向量包含指定的元素，则返回 true 。
boolean	containsAll(Collection<?> c) 如果此向量包含指定集合中的所有元素，则返回true。

E	get(int index) 返回此向量中指定位置的元素。

int	indexOf(Object o) 返回此向量中指定元素的第一次出现的索引，如果此向量不包含元素，则返回-1。
int	indexOf(Object o, int index) 返回此向量中指定元素的第一次出现的索引，从 index向前 index ，如果未找到该元素，则返回-1。

int	lastIndexOf(Object o) 返回此向量中指定元素的最后一次出现的索引，如果此向量不包含元素，则返回-1。
int	lastIndexOf(Object o, int index) 返回此向量中指定元素的最后一次出现的索引，从 index ，如果未找到元素，则返回-1

E	remove(int index) 删除此向量中指定位置的元素。
boolean	remove(Object o) 删除此向量中指定元素的第一个出现如果Vector不包含元素，则它不会更改。
boolean	removeAll(Collection<?> c) 从此Vector中删除指定集合中包含的所有元素。

E	set(int index, E element) 用指定的元素替换此Vector中指定位置的元素。

int	size() 返回此向量中的组件数。
void	sort(Comparator<? super E> c) 使用提供的 Comparator对此列表进行排序以比较元素。

List<E>	subList(int fromIndex, int toIndex) 返回此列表之间的fromIndex（包括）和toIndex之间的独占视图。
Object[]	toArray() 以正确的顺序返回一个包含此Vector中所有元素的数组。
<T> T[]	toArray(T[] a) 以正确的顺序返回一个包含此Vector中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。
String	toString() 返回此Vector的字符串表示形式，其中包含每个元素的String表示形式。

1.Vector类的定义说明：

2.Vector底层也是一个对象数组，protected Object[] elementData;

3.Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized关键字

public synchronized E get(int index){
	if(index >= elementCount)
	throw new ArrayIndexOuOfBoundsException(index);
	return elementData(index);
}

4.在开发中，需要线程同步安全时，考虑使用Vector

Vector底层源码剖析

    public static void main(String[] args) {
            Vector<String> strings = new Vector<>();
            for (int i = 0; i < 12; i++) {
                strings.add("A_"+i);
            }
   }  
   
   源码剖析
   
   步骤1：
  使用是无参构造创建 Vector 对象 默认 在底层创建一个 大小为10 protected  Object[] elementData;数组
   public Vector() {
        this(10);
    }
    
    步骤2：
    public synchronized boolean add(E e) {
        modCount++;// 对象 Vector修改的次数
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
    
    步骤3： 确定是否需要扩容 
    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);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);//将原来的数组拷贝到新的数组中
    }



	使用有参构造器创建 Vector 对象时，创建一个指定大小的 protected  Object[] elementData;数组
	步骤1：
	public Vector(int initialCapacity) {
        this(initialCapacity, 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;
    }
    
    步骤2：
    public synchronized boolean add(E e) {
        modCount++;// 对象 Vector修改的次数
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
    
    步骤3： 确定是否需要扩容 
    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);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);//将原来的数组拷贝到新的数组中
    }

Vector 和 ArrayList的比较