JDK1.8源码-09-java.util.Vector

字数统计: 4.7k字   |   阅读时长≈ 23分钟

JDK1.8源码-09-java.util.Vector

学完ArrayList和LinkedList之后，我们接着学习Vector。

1. 简介

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

Vector是矢量队列，它是JDK1.0版本添加的类。继承于AbstractList,实现了List接口。

mark

  • 实现了List:所以它是一个队列，支持相关的添加，删除，修改，遍历功能。

  • Vector 实现了RandmoAccess接口，即提供了随机访问功能。（其中RandomAccess接口，是java中用来被List实现，为List提供快速访问功能的。）

  • 在Vector中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。

  • Vector实现了Cloneable接口，即实现了clone()函数，它能被克隆。

注意：

  • 和Arraylist不同的是，Vector中的操作是线程安全的！！！。

2. 字段

mark

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
  
// 1. elementData是“Object []类型的数组”，它保存了添加到Vector中的元素
// elementData是一个动态数组，如果初始化Vector时，没有指定动态数组的大小，则默认使用大小10。
// 随着Vector中元素的增加，Vector的容量也会增加。

protected Object[] elementData;

// elementCount是动态数组的实际大小。
protected int elementCount;

// 3. capacityIncrement是动态数组的增长系数
// 如果在创建Vector,指定了capacityIncrement的大小，那就传入指定大小
// 每次当Vector中动态数组容量增加的时候，增加的大小都是capacityIncrement
// 具体的增长方式，请参考源码分析中的ensureCapacity()函数。
protected int capacityIncrement;

小结：

  • Vector实际上是通过一个数组去保存数据的。当我们构造Vector时候，若使用默认的构造函数，那么默认容量大小是10.

  • 当Vector容量不足以容纳全部元素的时候，若容量增加系数 >0，则将容量的值增加“容量增加系数”；否则，将容量大小增加一倍。

  • Vector的克隆函数，就是将全部元素克隆到一个数组中。

3. 构造函数

  1. 无参数构造函数
1
2
3
4
5
6
7
8
9
10
11
    /**
     * Constructs an empty vector so that its internal data array
     * has size {@code 10} and its standard capacity increment is
     * zero.
     */

// 默认是调用Vector(int initialCapacity)
// elementData是一个动态数组，如果初始化Vector时，没有指定动态数组的大小，则默认使用大小10。
    public Vector() {
        this(10);
    }
  1. 带初始化容量大小的构造方法
1
2
3
4
5
6
7
8
9
    * @param   initialCapacity   the initial capacity of the vector
    * @throws IllegalArgumentException if the specified initial capacity
    *         is negative
    */
        
// 默认是调用Vector(int initialCapacity, int capacityIncrement)
   public Vector(int initialCapacity) {
       this(initialCapacity, 0);
   }
  1. 带初始化容量和容量增量的构造方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    /**
     * Constructs an empty vector with the specified initial capacity and
     * capacity increment.
     *
     * @param   initialCapacity     the initial capacity of the vector
     * @param   capacityIncrement   the amount by which the capacity is
     *                              increased when the vector overflows
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     */
// capacity是Vector的默认容量大小
// capacityIncrement是每次Vector容量增加时的增量值。
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        // 如果初始化长度为0，抛出异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        // 新建一个数组，数组容量是initialCapacity
        this.elementData = new Object[initialCapacity];
        // 设置增长系数
        this.capacityIncrement = capacityIncrement;
    }
  1. 带Colleciton参数的构造方法
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
    /**
     * Constructs a vector containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param c the collection whose elements are to be placed into this
     *       vector
     * @throws NullPointerException if the specified collection is null
     * @since   1.2
     */
    public Vector(Collection<? extends E> c) {
        // 获取“集合(c)”的数组，并将其赋值给elementData
        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);
    }

// 这里是Arrays.copyOf的源码
    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

4. copyInto

调用本地方法：System.arraycopy

  • 把数组Vector的全部元素都拷贝到数组anArray中
1
2
3
public synchronized void copyInto(Object[] anArray) {
       System.arraycopy(elementData, 0, anArray, 0, elementCount);
   }

5. trimToSize

将当前容量值更新为实际元素的个数，方便GC的回收

1
2
3
4
5
6
7
8
9
public synchronized void trimToSize() {
    // 操作数+1
    modCount++;
    int oldCapacity = elementData.length;
    // 当前容量值更新为实际元素的个数
    if (elementCount < oldCapacity) {
        elementData = Arrays.copyOf(elementData, elementCount);
    }
}

6. ensureCapacity

以下几个函数作用于确定Vector的容量大小，以及扩容操作。

这里和ArrayList相比

除了扩容倍数有区别以外，其他几乎毫无区别

  • ArrayList：1.5倍
  • Vector: 2 倍
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
50
51
52
    
public synchronized void ensureCapacity(int minCapacity) {
        if (minCapacity > 0) {
            // 将Vector的改变统计数+1
            modCount++;
            ensureCapacityHelper(minCapacity);
        }
    }

	// 确认“Vector容量”的帮助函数	
    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        // 当Vector容量不足以容纳当前全部元素，进行扩容。
        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;
        // 如果容量增量系数>0，则容量增大capacityIncrement
        // 如果没指定capacityIncrement，容量扩大一倍(变为原来两倍)
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        // 当新数组长度仍然比minCapacity小，则为保证最小长度，新数组等于minCapacity
        if (newCapacity - minCapacity < 0)
            // 扩大为最小要求容量
            newCapacity = minCapacity;
        // 当新得到的数组长度比MAX_ARRAY_SIZE大的时候，
        // 调用hugeCapacity来处理大数组
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            // 调用大数组扩容操作
            newCapacity = hugeCapacity(minCapacity);
        // 调用Arrays.copyOf将原数组拷贝到
        // 一个大小为newCapacity大小的新数组中（注意是拷贝引用）
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

	//
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        // minCapacity > MAX_ARRAY_SIZE,
        // 则新数组大小为Integer.MAX_VALUE
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

7. setSize

  • 给Vector设置新的size大小
    • 若 “newSize 大于 Vector容量”，则调整Vector的大小。
    • 如果“newSize” 小于等于Vector的容量，则将从newSize位置开始的元素都设置为null
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
    // 设置容量是newSize
public synchronized void setSize(int newSize) {
        modCount++;
    //  若 "newSize 大于 Vector容量"，则调整Vector的大小。
        if (newSize > elementCount) {
            ensureCapacityHelper(newSize);
        } else {
            // 如果“newSize” 小于等于Vector的容量，
            // 则将从newSize位置开始的元素都设置为null
            for (int i = newSize ; i < elementCount ; i++) {
                elementData[i] = null;
            }
        }
        elementCount = newSize;
    }

8. Capacity&&Size

  • capacity返回Vector总的容量大小
1
2
3
4
5
6
7
8
9
10
/**
 * Returns the current capacity of this vector.
 *
 * @return  the current capacity (the length of its internal
 *          data array, kept in the field {@code elementData}
 *          of this vector)
 */
public synchronized int capacity() {
    return elementData.length;
}
  • size返回Vector实际的容量大小：（Vector中的元素个数）
1
2
3
4
5
6
7
8
/**
 * Returns the number of components in this vector.
 *
 * @return  the number of components in this vector
 */
public synchronized int size() {
    return elementCount;
}

9. isEmpty

  • 判读Vector是否为空
1
2
3
4
5
6
7
8
9
10
/**
 * Tests if this vector has no components.
 *
 * @return  {@code true} if and only if this vector has
 *          no components, that is, its size is zero;
 *          {@code false} otherwise.
 */
public synchronized boolean isEmpty() {
    return elementCount == 0;
}

10. Enumeration< E > elements()

mark

  • Enumeration只有两个方法：

    • boolean hasMoreElements();
<!--13-->

  • 它只能从首个元素遍历到最后一个元素，并不能根据位置拿到具体的元素。

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
/**
 * Returns an enumeration of the components of this vector. The
 * returned {@code Enumeration} object will generate all items in
 * this vector. The first item generated is the item at index {@code 0},
 * then the item at index {@code 1}, and so on.
 *
 * @return  an enumeration of the components of this vector
 * @see     Iterator
 */
public Enumeration<E> elements() {
    // 通过匿名类实现Enumeration
    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");
        }
    };
}

11 contains/containsAll

  • 判断Vector中是否包含对象o
1
2
3
4
5
6
7
8
9
10
11
12
/**
 * Returns {@code true} if this vector contains the specified element.
 * More formally, returns {@code true} if and only if this vector
 * contains at least one element {@code e} such that
 * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
 *
 * @param o element whose presence in this vector is to be tested
 * @return {@code true} if this vector contains the specified element
 */
public boolean contains(Object o) {
    return indexOf(o, 0) >= 0;
}
  • 判断Vector中是否包含一个集合c
1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 * Returns true if this Vector contains all of the elements in the
 * specified Collection.
 *
 * @param   c a collection whose elements will be tested for containment
 *          in this Vector
 * @return true if this Vector contains all of the elements in the
 *         specified collection
 * @throws NullPointerException if the specified collection is null
 */
public synchronized boolean containsAll(Collection<?> c) {
    return super.containsAll(c);
}

12. indexOf/lastIndexOF

  • 从index位置开始向后查找元素(o)。
  • 只返回第一个找到的位置索引，找不到返回-1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
   public int indexOf(Object o) {
       return indexOf(o, 0);
   }

	// 从index位置开始向后查找元素(o)。
// 只返回第一个找到的位置索引，找不到返回-1
   public synchronized int indexOf(Object o, int index) {
       if (o == null) {
           // 若查找元素为null，则正向找出null元素，并返回它对应的序号
           for (int i = index ; i < elementCount ; i++)
               if (elementData[i]==null)
                   return i;
       } else {
           // 若查找元素不为null，则正向找出该元素，并返回它对应的序号
           for (int i = index ; i < elementCount ; i++)
               if (o.equals(elementData[i]))
                   return i;
       }
       return -1;
   }

lastIndexOf:

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

// 若找到，则返回元素的“索引值”；否则，返回-1。
   public synchronized int lastIndexOf(Object o, int index) {
       if (index >= elementCount)
           throw new IndexOutOfBoundsException(index + " >= "+ elementCount);

       if (o == null) {
            // 若查找元素为null，则反向找出null元素，并返回它对应的序号
           for (int i = index; i >= 0; i--)
               if (elementData[i]==null)
                   return i;
       } else {
           // 若查找元素不为null，则反向找出该元素，并返回它对应的序号
           for (int i = index; i >= 0; i--)
               if (o.equals(elementData[i]))
                   return i;
       }
       return -1;
   }

13 elementAt

13.1 elementAt

1
2
3
4
5
6
7
8
  public synchronized E elementAt(int index) {
      // 越界，则抛出异常
      if (index >= elementCount) {
          throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
      }
// 返回index下标的元素
      return elementData(index);
  }

13.2 firstElement

  • 返回Vector中index=0位置的元素。
1
2
3
4
5
6
7
// 返回Vector中index=0位置的元素。
public synchronized E firstElement() {
        if (elementCount == 0) {
            throw new NoSuchElementException();
        }
        return elementData(0);
    }

13.3 lastElement

  • 获取Vector中的最后一个元素。
1
2
3
4
5
6
7
// 获取Vector中的最后一个元素。
public synchronized E lastElement() {
        if (elementCount == 0) {
            throw new NoSuchElementException();
        }
        return elementData(elementCount - 1);
    }

13.4 修改元素

  • 设置index位置的元素为obj
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;
}

13.5 删除元素

  • 本质是把index+1位置后面的元素拷贝到index位置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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;
    // 本质是把index+1位置后面的元素拷贝到index位置
    if (j > 0) {
        System.arraycopy(elementData, index + 1, elementData, index, j);
    }
    elementCount--;
    // 将删除的位置置为null,翻遍GC回收
    elementData[elementCount] = null; /* to let gc do its work */
}

13.6 插入元素

  • 把index+1位置后面的元素拷贝到index位置
  • 再把index位置的元素改为obj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public synchronized void insertElementAt(E obj, int index) {
    modCount++;
    if (index > elementCount) {
        throw new ArrayIndexOutOfBoundsException(index
                                                 + " > " + elementCount);
    }
    // 首先保证Vector的大小
    ensureCapacityHelper(elementCount + 1);
    // 把index+1位置后面的元素拷贝到index位置
    System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
    // 再把index位置的元素改为obj
    elementData[index] = obj;
    elementCount++;
}

14. 添加元素/add

  • 在末尾添加元素
1
2
3
4
5
6
7
public synchronized void addElement(E obj) {
    modCount++;
    // 首先保证Vector的大小
    ensureCapacityHelper(elementCount + 1);
    // 在末尾添加元素
    elementData[elementCount++] = obj;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 * Appends the specified element to the end of this Vector.
 *
 * @param e element to be appended to this Vector
 * @return {@code true} (as specified by {@link Collection#add})
 * @since 1.2
 */
public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}
1
2
3
public void add(int index, E element) {
    insertElementAt(element, index);
}
  • addAll()
1
2
3
4
5
6
7
8
9
10
public synchronized boolean addAll(Collection<? extends E> c) {
    modCount++;
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityHelper(elementCount + numNew);
    // 将集合c全部添加到Vector的末尾
    System.arraycopy(a, 0, elementData, elementCount, numNew);
    elementCount += numNew;
    return numNew != 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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)
        // 将集合c添加到index位置
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved);

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

15. removeElement/remove

  • 删除对应obj的索引位置的元素
1
2
3
4
5
6
7
8
9
10
11
public synchronized boolean removeElement(Object obj) {
    modCount++;
    // 拿到obj对应的索引值
    int i = indexOf(obj);
    if (i >= 0) {
        // 调用删除方法
        removeElementAt(i);
        return true;
    }
    return false;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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;
}
  • 删除所有的元素
1
2
3
4
5
6
7
8
9
// 所有元素置为null
public synchronized void removeAllElements() {
        modCount++;
        // Let gc do its work
        for (int i = 0; i < elementCount; i++)
            elementData[i] = null;

        elementCount = 0;
    }
1
2
3
4
5
6
7
8
9
/**
 * Removes all of the elements from this Vector.  The Vector will
 * be empty after this call returns (unless it throws an exception).
 *
 * @since 1.2
 */
public void clear() {
    removeAllElements();
}
  • 删除集合
1
2
3
4
// 删除不是集合c中的元素
public synchronized boolean retainAll(Collection<?> c) {
        return super.retainAll(c);
    }
1
2
3
4
// 删除集合c中的元素 
public synchronized boolean removeAll(Collection<?> c) {
        return super.removeAll(c);
    }
  • 删除范围元素
1
2
3
4
5
6
7
8
9
10
11
12
protected synchronized void removeRange(int fromIndex, int toIndex) {
    modCount++;
    int numMoved = elementCount - toIndex;
    // 相当于把fromindex到toindex之间抹掉了
    System.arraycopy(elementData, toIndex, elementData, fromIndex,
                     numMoved);

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

16. clone

1
2
3
4
5
6
7
8
9
10
11
12
13
public synchronized Object clone() {
    try {
        @SuppressWarnings("unchecked")
            Vector<E> v = (Vector<E>) super.clone();
        // 将当前Vector的全部元素拷贝到v中
        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(e);
    }
}

17. toArray

  • toArray
1
2
3
4
5
6
7
8
9
10
   /**
    * Returns an array containing all of the elements in this Vector
    * in the correct order.
    *
    * @since 1.2
    */
// 返回Object的数组
   public synchronized Object[] toArray() {
       return Arrays.copyOf(elementData, elementCount);
   }
  • toArray(T[] a)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@SuppressWarnings("unchecked")
public synchronized <T> T[] toArray(T[] a) {
    // 若数组a的大小 < Vector元素的个数
    if (a.length < elementCount)
        // 则新建一个T[] 数组，数组大小是elementCount(Vector元素大小)
        // 并且把Vector全部拷贝到新数组中
        return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());

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

    // 若数组a的大小 > Vector元素的个数
    // 把大于部分的元素都置为null
    if (a.length > elementCount)
        a[elementCount] = null;

    return a;
}

18. 获取元素/get

  • 获取index位置的元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * Returns the element at the specified position in this Vector.
 *
 * @param index index of the element to return
 * @return object at the specified index
 * @throws ArrayIndexOutOfBoundsException if the index is out of range
 *            ({@code index < 0 || index >= size()})
 * @since 1.2
 */
public synchronized E get(int index) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);

    return elementData(index);
}

19. 修改元素/set

  • 将index位置的元素置为element,并返回index位置的原始值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * Replaces the element at the specified position in this Vector with the
 * specified element.
 *
 * @param index index of the element to replace
 * @param element element to be stored at the specified position
 * @return the element previously at the specified position
 * @throws ArrayIndexOutOfBoundsException if the index is out of range
 *         ({@code index < 0 || index >= size()})
 * @since 1.2
 */
public synchronized E set(int index, E element) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);

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

20. equals/hashcode/toString

1
2
3
4
// 判断两个对象的引用是否相等
public synchronized boolean equals(Object o) {
        return super.equals(o);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * Returns the hash code value for this Vector.
 */
public synchronized int hashCode() {
    return super.hashCode();
}

/**
 * Returns a string representation of this Vector, containing
 * the String representation of each element.
 */
public synchronized String toString() {
    return super.toString();
}

21. subList

  • 获取Vector中fromIndex到toIndex的子集
1
2
3
4
public synchronized List<E> subList(int fromIndex, int toIndex) {
    return Collections.synchronizedList(super.subList(fromIndex, toIndex),
                                        this);
}

22. 内部类Itr迭代器

  • 用游标代替链表指向（这里在之前的LinkedArrayList中有详细讲过，这里不再阐述）
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
50
51
52
/**
 * An optimized version of AbstractList.ListItr
 */
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;
    }
}

23. 遍历方式

Vector支持4种遍历方式。建议使用下面的第二种去遍历Vector，因为效率问题。

  1. 第一种，通过迭代器遍历。即通过Iterator去遍历。
1
2
3
4
5
Integer value = null;
int size = vec.size();
for (int i=0; i<size; i++) {
    value = (Integer)vec.get(i);        
}
  1. 第二种，随机访问，通过索引值去遍历(由于Vector实现了RandomAccess接口，它支持通过索引值去随机访问元素。)
1
2
3
4
5
Integer value = null;
int size = vec.size();
for (int i=0; i<size; i++) {
    value = (Integer)vec.get(i);        
}
  1. 第三种，另一种for循环。如下：
1
2
3
4
Integer value = null;
for (Integer integ:vec) {
    value = integ;
}
  1. 第四种，Enumeration遍历，如下：
1
2
3
4
5
Integer value = null;
Enumeration enu = vec.elements();
while (enu.hasMoreElements()) {
    value = (Integer)enu.nextElement();
}

23.1 测试效率

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
public class VectorRandomAccessTest {

    public static void main(String[] args) {
        Vector vec= new Vector();
        for (int i=0; i<100000; i++)
            vec.add(i);
        iteratorThroughRandomAccess(vec) ;
        iteratorThroughIterator(vec) ;
        iteratorThroughFor2(vec) ;
        iteratorThroughEnumeration(vec) ;
    
    }

    private static void isRandomAccessSupported(List list) {
        if (list instanceof RandomAccess) {
            System.out.println("RandomAccess implemented!");
        } else {
            System.out.println("RandomAccess not implemented!");
        }

    }

    public static void iteratorThroughRandomAccess(List list) {

        long startTime;
        long endTime;
        startTime = System.currentTimeMillis();
        for (int i=0; i<list.size(); i++) {
            list.get(i);
        }
        endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println("iteratorThroughRandomAccess：" + interval+" ms");
    }

    public static void iteratorThroughIterator(List list) {

        long startTime;
        long endTime;
        startTime = System.currentTimeMillis();
        for(Iterator iter = list.iterator(); iter.hasNext(); ) {
            iter.next();
        }
        endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println("iteratorThroughIterator：" + interval+" ms");
    }


    public static void iteratorThroughFor2(List list) {

        long startTime;
        long endTime;
        startTime = System.currentTimeMillis();
        for(Object obj:list)
            ;
        endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println("iteratorThroughFor2：" + interval+" ms");
    }

    public static void iteratorThroughEnumeration(Vector vec) {

        long startTime;
        long endTime;
        startTime = System.currentTimeMillis();
        for(Enumeration enu = vec.elements(); enu.hasMoreElements(); ) {
            enu.nextElement();
        }
        endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println("iteratorThroughEnumeration：" + interval+" ms");
    }
}

运行结果：

1
2
3
4
iteratorThroughRandomAccess：6 ms
iteratorThroughIterator：9 ms
iteratorThroughFor2：8 ms
iteratorThroughEnumeration：7 ms

总结：遍历Vector，使用索引的随机访问方式最快，使用迭代器最慢。

24. API 示例学习

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
50
51
52
53
54
55
56
57
58
59
60
61
62
public static void main(String[] args) {
    // 1. 新建一个Vector
    Vector vec = new Vector<>();

    // 2. 添加元素
    vec.add("1");
    vec.add("2");
    vec.add("3");
    vec.add("4");
    vec.add("5");


    // 3. 设置元素
    vec.set(0, "100");


    // 4. 获取元素
    System.out.println("vec.firstElement():" + vec.firstElement());
    System.out.println("vec.lastElement():" + vec.lastElement());
    System.out.println("vec.elementAt(2):" + vec.elementAt(2));

    // 5. 查找
    System.out.println("vec.indexOf(100):" + vec.indexOf(100));
    System.out.println("vec.lastIndexOf(100):" + vec.lastIndexOf(100));

    // 6. 获取Vector的大小
    System.out.println("size" + vec.size());

    // 7. 获取Vector的总容量
    System.out.println("capacity" + vec.capacity());

    // 8. 获取一个范围的Vector
    System.out.println("vec 2 to 4" + vec.subList(1, 4));


    // 9. 通过Enumeration遍历Vector
    Enumeration enu = vec.elements();
    while (enu.hasMoreElements()) {
        System.out.println("nextElement" + enu.nextElement());
    }

    // 10. 获取"vec"包含在retainVec中元素的集合
    Vector retainVec = new Vector<>();
    retainVec.add("100");
    retainVec.add("300");

    System.out.println("vec.retain():" + vec.retainAll(retainVec));
    System.out.println("vec:" + vec);

    // 11. 获取vec对应的String数组
    String[] arr = (String[]) vec.toArray(new String[0]);
    for (String string : arr) {
        System.out.println("string" + string);
    }

    // 12. 清空Vector
    vec.clear();
    vec.removeAllElements();

    // 13. 判断Vector是否为空
    System.out.println("vec.isEmpty():" + vec.isEmpty());
}
打赏
  • 版权声明： 本博客所有文章除特别声明外，均采用 Apache License 2.0 许可协议。转载请注明出处！
  • © 2019-2022 Zhuuu
  • PV: UV:

请我喝杯咖啡吧~

支付宝
微信