java提高篇(二九)-----Vector

        java提高篇(二一)—–ArrayListjava提高篇(二二)—LinkedList,详细解说了ArrayList、linkedList的原理和实现过程,对于List接口这里还介绍一个它的实现类Vector,Vector 类能够实现可增长的对象数组。

一、Vector简单介绍

        Vector能够实现可增长的对象数组。与数组一样,它包括能够使用整数索引进行訪问的组件。只是,Vector的大小是能够添加�或者减小的,以便适应创建Vector后进行加入�或者删除操作。

        Vector实现List接口,继承AbstractList类,所以我们能够将其看做队列,支持相关的加入�、删除、改动、遍历等功能。

        Vector实现RandmoAccess接口,即提供了随机訪问功能,提供提供高速訪问功能。在Vector我们能够直接訪问元素。

        Vector 实现了Cloneable接口,支持clone()方法,能够被克隆。

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

        Vector提供了四个构造函数:

/**
     * 构造一个空向量,使其内部数据数组的大小为 10,其标准容量增量为零。
     */
     public Vector() {
            this(10);
     }
    
    /**
     * 构造一个包括指定 collection 中的元素的向量,这些元素按其 collection 的迭代器返回元素的顺序排列。
     */
    public Vector(Collection<? extends E> c) {
        elementData = c.toArray();
        elementCount = elementData.length;
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, elementCount,
                    Object[].class);
    }
    
    /**
     * 使用指定的初始容量和等于零的容量增量构造一个空向量。
     */
    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;
    }

        在成员变量方面,Vector提供了elementData , elementCount, capacityIncrement三个成员变量。当中

        elementData :"Object[]类型的数组",它保存了Vector中的元素。依照Vector的设计elementData为一个动态数组,能够随着元素的添加�而动态的增长,其详细的添加�方式后面提到(ensureCapacity方法)。假设在初始化Vector时没有指定容器大小,则使用默认大小为10.

        elementCount:Vector 对象中的有效组件数。

        capacityIncrement:向量的大小大于其容量时,容量自己主动添加�的量。假设在创建Vector时,指定了capacityIncrement的大小;则,每次当Vector中动态数组容量添加�时>,添加�的大小都是capacityIncrement。假设容量的增量小于等于零,则每次须要增大容量时,向量的容量将增大一倍。

        同一时候Vector是线程安全的!

二、源代码解析

        对于源代码的解析,LZ在这里仅仅就添加�(add)删除(remove)两个方法进行解说。

2.1添加�:add(E e)

        add(E e):将指定元素加入�到此向量的末尾。

public synchronized boolean add(E e) {
        modCount++;     
        ensureCapacityHelper(elementCount + 1);    //确认容器大小,假设操作容量则扩容操作
        elementData[elementCount++] = e;   //将e元素加入�至末尾
        return true;
    }

        这种方法相对而言比較简单,详细过程就是先确认容器的大小,看是否须要进行扩容操作,然后将E元素加入�到此向量的末尾。

private void ensureCapacityHelper(int minCapacity) {
        //假设
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    /**
     * 进行扩容操作
     * 假设此向量的当前容量小于minCapacity,则通过将其内部数组替换为一个较大的数组俩添加�其容量。
     * 新数据数组的大小姜维原来的大小 + capacityIncrement,
     * 除非 capacityIncrement 的值小于等于零,在后一种情况下,新的容量将为原来容量的两倍,只是,假设此大小仍然小于 minCapacity,则新容量将为 minCapacity。
     */
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;     //当前容器大小
        /*
         * 新容器大小
         * 若容量增量系数(capacityIncrement) > 0,则将容器大小添加�到capacityIncrement
         * 否则将容量添加�一倍
         */
        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);
    }
    
    /**
     * 推断是否超出最大范围
     * MAX_ARRAY_SIZE:private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
     */
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
    }

        对于Vector整个的扩容过程,就是依据capacityIncrement确认扩容大小的,若capacityIncrement <= 0 则扩大一倍,否则扩大至capacityIncrement 。当然这个容量的最大范围为Integer.MAX_VALUE即,2^32 - 1,所以Vector并非能够无限扩充的。

2.2、remove(Object o)

/**
     * 从Vector容器中移除指定元素E
     */
    public boolean remove(Object o) {
        return removeElement(o);
    }

    public synchronized boolean removeElement(Object obj) {
        modCount++;
        int i = indexOf(obj);   //计算obj在Vector容器中位置
        if (i >= 0) {
            removeElementAt(i);   //移除
            return true;
        }
        return false;
    }
    
    public synchronized void removeElementAt(int index) {
        modCount++;     //改动次数+1
        if (index >= elementCount) {   //删除位置大于容器有效大小
            throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
        }
        else if (index < 0) {    //位置小于 < 0
            throw new ArrayIndexOutOfBoundsException(index);
        }
        int j = elementCount - index - 1;
        if (j > 0) {   
            //从指定源数组中复制一个数组,复制从指定的位置開始,到目标数组的指定位置结束。
            //也就是数组元素从j位置往前移
            System.arraycopy(elementData, index + 1, elementData, index, j);
        }
        elementCount--;   //容器中有效组件个数 - 1
        elementData[elementCount] = null;    //将向量的末尾位置设置为null
    }

        由于Vector底层是使用数组实现的,所以它的操作都是对数组进行操作,仅仅只是其是能够随着元素的添加�而动态的改变容量大小,事实上现方法是是使用Arrays.copyOf方法将旧数据复制到一个新的大容量数组中。Vector的整个内部实现都比較简单,这里就不在重述了。

三、Vector遍历

        Vector支持4种遍历方式。

3.1、随机訪问

        由于Vector实现了RandmoAccess接口,能够通过下标来进行随机訪问。

for(int i = 0 ; i < vec.size() ; i++){
        value = vec.get(i);
    }

3.2、迭代器

Iterator it = vec.iterator();
    while(it.hasNext()){
        value = it.next();
        //do something
    }

3.2、for循环

for(Integer value:vec){
        //do something
    }

3.4、Enumeration循环

Vector vec = new Vector<>();
    Enumeration enu = vec.elements();
    while (enu.hasMoreElements()) {
        value = (Integer)enu.nextElement();
    }
——————————————————————————————————————————————————————————————————————————
--      原文出自:http://cmsblogs.com/?p=1180。尊重作者的成果,转载请注明出处!                           

--     个人网站:http://cmsblogs.com        

你可能感兴趣的:(vector)