close

Mr.Muzi

一只很安静的monkey

Java Collection 04 - Vector

字数统计: 5.7k 阅读时长: 25 mins • 分类: 源码阅读 • 标签: JDK 1.7, Java集合

  关于 java.util.Vector<E> 的部分笔记。Vector是线程安全版本的、可变长度的、可用随机访问的方式获取元素的、基于数组实现的集合容器实现类。但是由于其主要方法都通过synchronized保证了多线程的线程安全特性，所以其性能相对ArrayList而言会慢很多。本文演示代码段的执行环境基于JDK版本1.7。

概述

  Vector是一个可变长度的集合容器，底层是基于数组实现的。由于其同样实现了RandomAccess接口，所以可以按照随机访问的方式来访问集合中的元素。

  Vector生成的iterators同样带有快速失败属性。如果某个迭代器在运行时发现Vector集合最近一次的结构化修改不是由迭代器自身完成的，那么会抛出ConcurrentModificationException异常。

  在List中，支持随机访问存储的集合实现有ArrayList和Vector。二者的底层实现都是依赖于数组完成的。但是ArrayList在多线程环境下无法保证线程安全，而Vector则可以用于多线程环境下的元素存储需要，通过在方法声明中加入synchronized关键字来保证多线程环境的线程安全。所以如果需要在多线程环境下实现可随机访问的List集合，那么需要使用的是Vector而不是ArrayList。需要注意的是，由于Vector的多线程特性，所以其性能会稍逊于ArrayList。所以，如果没有实际的多线程环境需要，可用ArrayList来替换Vector以提高性能。

 

继承关系

1
2
3
4
5
// Vector<E>
--java.lang.Object
  --java.util.AbstractCollection<E>
    --java.util.AbstractList<E>
      --java.util.Vector<E>

 

实现接口

类名 实现接口
Vector<E> Iterable<E>, Collection<E>, List<E>, RandomAccess, Serializable, Cloneable

 

Vector

Constructor Summary

public Vector(int initialCapacity, int capacityIncrement)

1
2
3
4
5
6
7
8
public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}

  根据入参initialCapacity指定的长度初始化一个Vector空集合实例。capacityIncrement参数指定了Vector在执行扩容操作时依据的扩容规模大小。

public Vector(int initialCapacity)

1
2
3
4
5
6
7
public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}

public Vector() {
    this(10);
}

  根据入参initialCapacity指定的长度初始化一个Vector空集合实例。capacityIncrement默认为0。

public Vector(Collection<? extends E> c)

1
2
3
4
5
6
7
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);
}

  根据集合c初始化一个Vector集合实例，并将c中的内容复制到实例化后的集合实例中。初始化的实例集合中元素的位置和c一致。

  elementCount是Vector当前已经容纳的元素数，非Vector可以容纳的元素总数，Vector可以容纳的元素总数可以从elementData.length中得到。

部分方法

public void trimToSize()

1
2
3
4
5
6
public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = Arrays.copyOf(elementData, size);
    }
}

  缩小Vector的存储容量。将暂时尚未存储元素的空间全部释放掉。

public synchronized void copyInto(Object[] anArray)

1
2
3
public synchronized void copyInto(Object[] anArray) {
    System.arraycopy(elementData, 0, anArray, 0, elementCount);
}

  将Vector中的元素复制到数组anArray中。由于System.arraycopy是浅复制，所以对anArray的修改会同步出现在Vector的集合中。

public synchronized void ensureCapacity(int minCapacity)

1
2
3
4
5
6
public synchronized void ensureCapacity(int minCapacity) {
    if (minCapacity > 0) {
        modCount++;
        ensureCapacityHelper(minCapacity);
    }
}

  扩容操作。由于扩容操作会修改Vector集合的空间大小，所以需要记录modCount值。这个方法没有在Vector内部调用，如果在需要用Vector的场景中可以预先估计到可能存储的元素数量，那么可以调用该方法提前完成内存空间的分配进而避免频繁分配存储空间降低执行性能。

private void ensureCapacityHelper(int minCapacity)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
private void ensureCapacityHelper(int minCapacity) {
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

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

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
    MAX_ARRAY_SIZE;
}

  扩容底层操作。如果调用时需要的容量大小超过了当前Vector的elementData长度就执行扩容操作。反之不做处理。在计算扩充后容量时，如果指定了capacityIncrement大小，那么就在当前Vector空间容量的基础上增加capacityIncrement个空间。反之，如果未指定capacityIncrement大小，那么扩容后容量是当前容量的两倍大小。如果扩容后数量还是无法满足参数要求，那么就将Vector空间扩容为参数minCapacity指定的大小。

public synchronized void setSize(int newSize)

1
2
3
4
5
6
7
8
9
10
11
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;
}

  重置Vector的存储元素个数。由于该操作会修改Vector集合的存储元素数，所以需要记录modCount值。如果newSize大于Vector集合中存储的元素数，那么就执行扩容处理，空出部分被填充为null。反之，则清除自newSize及以后位置的元素，并释放空间。最后更新elementCount，该字段标记了Vector集合中存储的元素个数。

public synchronized int capacity()

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

  返回Vector集合的空间大小，既可以容纳的元素个数。

public synchronized int size()

1
2
3
4
5
6
7
public synchronized int size() {
    return elementCount;
}

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

  返回Vector集合当前存储的元素个数。如果elementCount为0，那么isEmpty()方法就会返回true，否则返回false。

public Enumeration<E> elements()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public Enumeration<E> elements() {
    return new Enumeration<E>() {
        int count = 0;

        public boolean hasMoreElements() {
            return count < elementCount;
        }

        public E nextElement() {
            synchronized (Vector.this) {
                if (count < elementCount) {
                    return elementData(count++);
                }
            }
            throw new NoSuchElementException("Vector Enumeration");
        }
    };
}

  以枚举方式返回Vector集合中的每一个元素。

public boolean contains(Object o)

1
2
3
public boolean contains(Object o) {
    return indexOf(o, 0) >= 0;
}

  判断当前Vector集合中是否含有元素o。如果Vector集合存储了一个及以上元素o，那么就返回true，否则返回false。

public int indexOf(Object o)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public int indexOf(Object o) {
    return indexOf(o, 0);
}

public synchronized int indexOf(Object o, int index) {
    if (o == null) {
        for (int i = index ; i < elementCount ; i++)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = index ; i < elementCount ; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

  返回元素o在Vector集合中第一次出现的位置（即o在集合中第一次被存储的位置）。如果元素o为null，那么就返回null第一次被存储的位置，否则返回非null元素在Vector集合中第一次出现的位置。如果元素o不存在于集合Vector中，那么返回-1。

public synchronized int lastIndexOf(Object o)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public synchronized int lastIndexOf(Object o) {
    return lastIndexOf(o, elementCount-1);
}

public synchronized int lastIndexOf(Object o, int index) {
    if (index >= elementCount)
        throw new IndexOutOfBoundsException(index + " >= "+ elementCount);

    if (o == null) {
        for (int i = index; i >= 0; i--)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = index; i >= 0; i--)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

  返回元素o在Vector集合中最后一次出现的位置（即o在集合中最后一次被存储的位置）。将当前Vector集合从尾向首逐个遍历，如果元素o为null，那么就返回null最后一次被存储的位置，否则返回非null元素在Vector集合中最后一次出现的位置。如果元素o不存在于集合Vector中，那么返回-1。

public synchronized E elementAt(int index)

1
2
3
4
5
6
7
public synchronized E elementAt(int index) {
    if (index >= elementCount) {
        throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
    }

    return elementData(index);
}

  返回Vector中index位置指定的元素。如果index指示位置大于Vector的元素个数（index >= elementCount）则抛出边界溢出异常。实际调用elementData(int index)方法完成所有操作。

E elementData(int index)

1
2
3
4
@SuppressWarnings("unchecked")
E elementData(int index) {
    return (E) elementData[index];
}

  返回Vector中index位置处的元素。

public synchronized E firstElement()

1
2
3
4
5
6
public synchronized E firstElement() {
    if (elementCount == 0) {
        throw new NoSuchElementException();
    }
    return elementData(0);
}

  返回Vector集合中第一个元素。

public synchronized E lastElement()

1
2
3
4
5
6
public synchronized E lastElement() {
    if (elementCount == 0) {
        throw new NoSuchElementException();
    }
    return elementData(elementCount - 1);
}

  返回Vector集合中最后一个元素。

public synchronized void setElementAt(E obj, int index)

1
2
3
4
5
6
7
public synchronized void setElementAt(E obj, int index) {
    if (index >= elementCount) {
        throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                 elementCount);
    }
    elementData[index] = obj;
}

  将index位置处的元素置换为obj。

public synchronized void removeElementAt(int index)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public synchronized void removeElementAt(int index) {
    modCount++;
    if (index >= elementCount) {
        throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                 elementCount);
    }
    else if (index < 0) {
        throw new ArrayIndexOutOfBoundsException(index);
    }
    int j = elementCount - index - 1;
    if (j > 0) {
        System.arraycopy(elementData, index + 1, elementData, index, j);
    }
    elementCount--;
    elementData[elementCount] = null; /* to let gc do its work */
}

  移除index位置处的元素。因为元素移除属于结构化修改，所以需要维护modCount的值。接着需要通过边界检查判定index的合法性以避免边界溢出。然后将index位置之后的元素（不包括index）统一向前移动一个单位，便会覆盖移除掉index位置处的元素。最后维护elementCount并更新其值。

public synchronized void insertElementAt(E obj, int index)

1
2
3
4
5
6
7
8
9
10
11
public synchronized void insertElementAt(E obj, int index) {
    modCount++;
    if (index > elementCount) {
        throw new ArrayIndexOutOfBoundsException(index
                                                 + " > " + elementCount);
    }
    ensureCapacityHelper(elementCount + 1);
    System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
    elementData[index] = obj;
    elementCount++;
}

  在index位置处插入元素obj。因为元素插入属于结构化修改，所以需要维护modCount的值。接着需要通过边界检查判定index的合法性以避免边界溢出。然后判断当前集合空间是否足够，如果空间不足的话需要执行扩容操作。最后将index位置之后的元素（包括index）统一向后移动一个单位，加入传入的元素obj，并维护更新elementCount的值。

public synchronized boolean add(E e)

1
2
3
4
5
6
public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}

  向Vector集合中加入元素o，返回true表示加入成功。

public void add(int index, E element)

1
2
3
public void add(int index, E element) {
    insertElementAt(element, index);
}

  向Vector集合中index指定的位置处加入元素element。

public synchronized void addElement(E obj)

1
2
3
4
5
public synchronized void addElement(E obj) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = obj;
}

  向Vector集合中加入一个元素obj。因为元素加入属于结构化修改，所以需要维护modCount的值。加入元素之前需要先判断是否有必要执行扩容处理，如果需要的话先完成扩容处理提供足够的空间来容纳新元素。最后在集合尾部将元素obj加入到集合中。

public synchronized boolean addAll(int index, Collection<? extends E> c)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public synchronized boolean addAll(int index, Collection<? extends E> c) {
    modCount++;
    if (index < 0 || index > elementCount)
        throw new ArrayIndexOutOfBoundsException(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityHelper(elementCount + numNew);

    int numMoved = elementCount - index;
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved);

    System.arraycopy(a, 0, elementData, index, numNew);
    elementCount += numNew;
    return numNew != 0;
}

  将集合c中的元素全部加入到Vector集合中自index位置起的空间里。因为元素加入属于结构化修改，所以需要维护modCount的值。获取到c集合中的元素数据内容和元素个数，判断当前Vector集合是否有足够空间存储c中所有元素，如果空间不足则需要执行扩容操作。第11 ~ 13行代码将Vector集合中自index位置起，长度为c中集合元素数的空间里存储的元素统一向后移动，留出的空间被用来存储c中元素。最后将c中元素存储到Vector集合中指定位置的空间里，更新elementCount的值。

public synchronized boolean addAll(Collection<? extends E> c)

1
2
3
4
5
6
7
8
9
public synchronized boolean addAll(Collection<? extends E> c) {
    modCount++;
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityHelper(elementCount + numNew);
    System.arraycopy(a, 0, elementData, elementCount, numNew);
    elementCount += numNew;
    return numNew != 0;
}

  将集合c中的元素全部加入到Vector集合中。因为元素加入属于结构化修改，所以需要维护modCount的值。获取到c集合中的元素数据内容和元素个数，判断当前Vector集合是否有足够空间存储c中所有元素，如果空间不足则需要执行扩容操作。空间充足时将c中元素存储到Vector集合中，更新elementCount的值。

public synchronized E remove(int index)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public synchronized E remove(int index) {
    modCount++;
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);
    E oldValue = elementData(index);

    int numMoved = elementCount - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--elementCount] = null; // Let gc do its work

    return oldValue;
}

  移除index位置处存储的元素并返回被移除的元素。

public synchronized boolean removeElement(Object obj)

1
2
3
4
5
6
7
8
9
public synchronized boolean removeElement(Object obj) {
    modCount++;
    int i = indexOf(obj);
    if (i >= 0) {
        removeElementAt(i);
        return true;
    }
    return false;
}

  移除Vector集合中删除元素obj。删除原则是先判断obj是否存在于集合中，如果不存在返回false，否则确定obj被存储的下标index最小的位置，并把该位置处存储的obj删除调，返回true标识成功删除元素obj。

public boolean remove(Object o)

1
2
3
public boolean remove(Object o) {
    return removeElement(o);
}

  移除Vector集合中删除元素o。

public synchronized void removeAllElements()

1
2
3
4
5
6
7
8
public synchronized void removeAllElements() {
    modCount++;
    // Let gc do its work
    for (int i = 0; i < elementCount; i++)
        elementData[i] = null;

    elementCount = 0;
}

  清空Vector集合中的所有元素。集合容量重置为0。

public synchronized boolean removeAll(Collection<?> c)

1
2
3
public synchronized boolean removeAll(Collection<?> c) {
    return super.removeAll(c);
}

  移除同时存在于Vector集合和c集合中的元素。调用的是AbstractCollection.removeAll(Collection<?> c)。

public void clear()

1
2
3
public void clear() {
    removeAllElements();
}

  清空Vector集合中的所有元素。集合容量重置为0。

public synchronized Object clone()

1
2
3
4
5
6
7
8
9
10
11
12
public synchronized Object clone() {
    try {
        @SuppressWarnings("unchecked")
        Vector<E> v = (Vector<E>) super.clone();
        v.elementData = Arrays.copyOf(elementData, elementCount);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError();
    }
}

  对象克隆复制。浅度复制，对复制内容的修改会在Vector集合中显现，反之亦然。

public synchronized Object[] toArray()

1
2
3
public synchronized Object[] toArray() {
    return Arrays.copyOf(elementData, elementCount);
}

  将Vector集合中的元素按照数组的方式返回。

public synchronized <T> T[] toArray(T[] a)

1
2
3
4
5
6
7
8
9
10
11
12
@SuppressWarnings("unchecked")
public synchronized <T> T[] toArray(T[] a) {
    if (a.length < elementCount)
        return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());

    System.arraycopy(elementData, 0, a, 0, elementCount);

    if (a.length > elementCount)
        a[elementCount] = null;

    return a;
}

  将Vector集合中的元素以数组的方式存储到数组a中。如果a的空间小于Vector集合的元素数，那么就返回一个新的数组对象，该对象中以a的类型为基础，且存储的是Vector集合中的元素数据内容。如果a的长度大于集合中存储的元素总数，那么a数组中最后一个元素的下一个存储位置会被置为null，如果集合中没有存储任何null元素，那么这个操作执行完成后便可以非常方便的得到集合中存储的元素总数。

E elementData(int index)

1
2
3
4
@SuppressWarnings("unchecked")
E elementData(int index) {
    return (E) elementData[index];
}

  返回Vector集合中index位置处的元素。

public synchronized E get(int index)

1
2
3
4
5
6
public synchronized E get(int index) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);

    return elementData(index);
}

  返回Vector集合中index位置处的元素。在有效使用index之前对index做了边界校验，避免越界溢出发生。

public synchronized E set(int index, E element)

1
2
3
4
5
6
7
8
public synchronized E set(int index, E element) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

  将Vector集合中index位置处的元素替换为element，并返回被替换的元素。

public synchronized boolean containsAll(Collection<?> c)

1
2
3
public synchronized boolean containsAll(Collection<?> c) {
    return super.containsAll(c);
}

  判断Vector集合中是否包含c中所有元素。如果Vecto集合包含c中所有元素，那么返回true，否则返回false。实际调用AbstractCollection.containsAll(Collection<?> c)完成操作。

public synchronized boolean retainAll(Collection<?> c)

1
2
3
public synchronized boolean retainAll(Collection<?> c) {
    return super.retainAll(c);
}

  保留同时包含在Vector集合和c集合中的元素，对于只存在于Vector集合，不存在于c集合的元素会被删除掉，类似于数学领域内的两个集合取交集操作。实际调用AbstractCollection.retainAll(Collection<?> c)完成操作。

public synchronized boolean equals(Object o)

1
2
3
public synchronized boolean equals(Object o) {
    return super.equals(o);
}

  判断当前Vector集合是否等于对象o。实际调用AbstractList.equals(Object o)完成操作。

public synchronized int hashCode()

1
2
3
public synchronized int hashCode() {
    return super.hashCode();
}

  返回当前Vector集合的散列值。实际调用AbstractList.hashCode()完成操作。

public synchronized String toString()

1
2
3
public synchronized String toString() {
    return super.toString();
}

  返回当前Vector集合的字符串表示，内部元素也以字符串形式表示。实际调用AbstractCollection.toString()完成操作。

public synchronized List<E> subList(int fromIndex, int toIndex)

1
2
3
public synchronized List<E> subList(int fromIndex, int toIndex) {
    return Collections.synchronizedList(super.subList(fromIndex, toIndex), this);
}

  通过调用AbstractList.subList(int fromIndex, int toIndex)方法获取Vector集合中自fromIndex位置起，到toIndex位置之间的子集合并返回。由于Vector被应用于多线程环境，而subList(int fromIndex, int toIndex)返回的是一个非线程安全的随机访问集合，所以通过Collections.synchronizedList(List list, Object mutex)可以保证返回的subList具有多线程环境的线程安全特性。

protected synchronized void removeRange(int fromIndex, int toIndex)

1
2
3
4
5
6
7
8
9
10
11
protected synchronized void removeRange(int fromIndex, int toIndex) {
    modCount++;
    int numMoved = elementCount - toIndex;
    System.arraycopy(elementData, toIndex, elementData, fromIndex,
                     numMoved);

    // Let gc do its work
    int newElementCount = elementCount - (toIndex-fromIndex);
    while (elementCount != newElementCount)
        elementData[--elementCount] = null;
}

  移除Vector集合中自fromIndex位置起，到toIndex位置之间的所有元素。操作过程可见图1：

1543839602703

图 - 1
 

  在alpha阶段由fromIndex和toIndex指定了需要删除的范围。第3 ~ 5行代码执行完之后则到达bravo阶段。灰色区域为fromIndex之前的元素，无变化。红色区域的元素由alpha阶段toIndex位置及之后的元素向左移动得到。第8行代码重新计算得到了newElementCount，也是从集合尾部删除元素操作的终点位置。在charlie中，elementCount逐个向左移动并删除元素释放空间，直到其到达newElementCount位置便停止操作。

private void writeObject(java.io.ObjectOutputStream s)

1
2
3
4
5
6
7
8
9
10
11
12
private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException {
    final java.io.ObjectOutputStream.PutField fields = s.putFields();
    final Object[] data;
    synchronized (this) {
        fields.put("capacityIncrement", capacityIncrement);
        fields.put("elementCount", elementCount);
        data = elementData.clone();
    }
    fields.put("elementData", data);
    s.writeFields();
}

  序列化写操作。将当前Vector集合对象的内容以自定义的方式重新实现了其序列化过程。

public synchronized Iterator<E> iterator()

1
2
3
public synchronized Iterator<E> iterator() {
    return new Itr();
}

  返回一个基于Vector集合的迭代器。该迭代器只能对集合做向后遍历。Itr类的相关实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    public boolean hasNext() {
        // Racy but within spec, since modifications are checked
        // within or after synchronization in next/previous
        return cursor != elementCount;
    }

    public E next() {
        synchronized (Vector.this) {
            checkForComodification();
            int i = cursor;
            if (i >= elementCount)
                throw new NoSuchElementException();
            cursor = i + 1;
            return elementData(lastRet = i);
        }
    }

    public void remove() {
        if (lastRet == -1)
            throw new IllegalStateException();
        synchronized (Vector.this) {
            checkForComodification();
            Vector.this.remove(lastRet);
            expectedModCount = modCount;
        }
        cursor = lastRet;
        lastRet = -1;
    }

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

public synchronized ListIterator<E> listIterator(int index)

1
2
3
4
5
6
7
8
9
public synchronized ListIterator<E> listIterator(int index) {
    if (index < 0 || index > elementCount)
        throw new IndexOutOfBoundsException("Index: "+index);
    return new ListItr(index);
}

public synchronized ListIterator<E> listIterator() {
    return new ListItr(0);
}

  返回一个基于Vector集合的可以从index位置开始遍历的迭代器。如果index参数没有传，那么默认从首部位置开始迭代。该迭代器可以对Vector集合进行双向遍历。ListItr(0)的相关实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
final class ListItr extends Itr implements ListIterator<E> {
    ListItr(int index) {
        super();
        cursor = index;
    }

    public boolean hasPrevious() {
        return cursor != 0;
    }

    public int nextIndex() {
        return cursor;
    }

    public int previousIndex() {
        return cursor - 1;
    }

    public E previous() {
        synchronized (Vector.this) {
            checkForComodification();
            int i = cursor - 1;
            if (i < 0)
                throw new NoSuchElementException();
            cursor = i;
            return elementData(lastRet = i);
        }
    }

    public void set(E e) {
        if (lastRet == -1)
            throw new IllegalStateException();
        synchronized (Vector.this) {
            checkForComodification();
            Vector.this.set(lastRet, e);
        }
    }

    public void add(E e) {
        int i = cursor;
        synchronized (Vector.this) {
            checkForComodification();
            Vector.this.add(i, e);
            expectedModCount = modCount;
        }
        cursor = i + 1;
        lastRet = -1;
    }
}

 

涉及基础知识点

  1. Enumeration和Iterator的联系

      Enumeration接口是JDK1.0时推出的，在JDK1.5之后为Enumeration接口进行了扩充，增加了泛型的操作应用。Iterator迭代器取代了 Enumeration的功能，同时增添了删除元素的方法，并且对方法的名称进行了改进。为什么还要使用Enumeration？这是因为一些比较古老的系统或者类库中的方法还在使用Enumeration接口，因此为了兼容，继续保留Enumeration相关定义保证代码正常有效。本文中涉及到的Vector就仍有Enumeration的具体实现。还有Iterator 是 Fast-Fail的，但 Enumeration不是，也就是说，Iteartor可以对非自身作出的结构化修改作出响应，而Enumeration没有这方面的判断和操作。

  2. Vector实现writeObject(java.io.ObjectOutputStream s)的意义

      和ArrayList一样，Vector自己实现了writeObject方法用来对elementData、elementCount和capacityIncrement执行序列化操作。Vector通过writeObject把elementData、elementCount和capacityIncrement里的元素写入到输出流ObjectOutputStream )中，通过默认处理从输入流（ObjectInputStream ）读取到被序列化的数据并反序列化之后存储到elementData。

      需要注意的是，writeObject方法都被声明为私有方法，且在Vector内部没有任何地方调用了该方法。实际上，这两个方法是通过反射的方式出现在了ObjectOutputStream、的方法writeObject()和调用栈中。

  3. 为什么线程安全的Vector会比非线程安全的ArrayList慢

      多线程环境中涉及到一个概念—上下文切换。由于CPU同一个时刻只能执行一个任务，所以如果让CPU在不同的任务之间来回切换任务执行的话不可避免的会执行保存当前任务状态、加载下一个任务状态、执行下一个任务等过程。任务的状态保存和再加载过程被称为上下文切换。而上下文切换会导致直接直接的性能消耗：状态和任务的加载、再加载，也包括间接的性能消耗：不同线程之间的数据共享等问题。

 

参考文献

  1. LINFO. Context Switch Definition [E]
  2. Wikipedia. 上下文交换 [E]
  3. rhwayfunn. Java并发编程系列之三十：多线程的代价 [E]

 
 
 
 

------------- End of this article, thanks! -------------
 


  版权声明：本文由N.C.Lee创作和发表，采用署名(BY)-非商业性使用(NC)-相同方式共享(SA)国际许可协议进行许可，转载请注明作者及出处。
  本文作者为 N.C.Lee
  本文标题为 Java Collection 04 - Vector
  本文链接为 https://marcuseddie.github.io/2018/java-Collection-Vector.html