Java集合篇：Vector

一、Vector简介：

（1）Vector可以实现可增长的对象数组。与数组一样，可以使用整数索引进行访问的组件。不过，Vector的大小是可以增加或者减小的，以便适应创建Vector后进行添加或者删除操作。

（2）同时Vector是线程安全的！底层使用的是synchronized进行加锁。

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

1、Vector实现List接口，继承AbstractList类，所以我们可以将其看做队列，支持相关的添加、删除、修改、遍历等功能。

Vector实现RandmoAccess接口，即提供了随机访问功能，提供提供快速访问功能。在Vector我们可以直接访问元素。

Vector 实现了Cloneable接口，支持clone()方法，可以被克隆。

Vector实现了Serializable接口，因此可以进行序列化。

2、成员变量方面，Vector提供了elementData , elementCount， capacityIncrement三个成员变量。其中

（1）elementData ："Object[]类型的数组"，它保存了Vector中的元素，是一个动态数组，可以随着元素的增加而动态的增长，（具体增长方式在ensureCapacity方法中）。如果在初始化Vector时没有指定容器大小，则使用默认大小为10。

（2）elementCount：Vector 对象中的元素个数。

（3）capacityIncrement：向量的大小大于其容量时，容量自动增加的量。如果在创建Vector时，指定了capacityIncrement的大小，则每次当Vector中动态数组容量增加时，增加的大小都是capacityIncrement。如果容量的增量小于等于零，则每次需要增大容量时，向量的容量将增大一倍。

二、Vector遍历：

//第一种：通过下标进行随机访问
for(int i = 0 ; i < vec.size() ; i++){value = vec.get(i);}//第二种：迭代器：
Iterator it = vec.iterator();while(it.hasNext()){value = it.next();//do something}//第三种：for循环
for(Integer value:vec){//do something}//第四种：Enumeration循环:
Vector vec = new Vector<>();Enumeration enu = vec.elements();while (enu.hasMoreElements()) {value = (Integer)enu.nextElement();}

Vector示例代码：

public class Hello {public static void main(String[] args) {Vector vec = new Vector();// 添加vec.add("1");vec.add("2");vec.add("3");vec.add("4");vec.add("5");// 替换vec.set(0, "100");vec.add(2, "300");System.out.println("vec:" + vec);System.out.println("vec.indexOf(100):" + vec.indexOf("100"));System.out.println("vec.lastIndexOf(100):" + vec.lastIndexOf("100"));System.out.println("vec.firstElement():" + vec.firstElement());System.out.println("vec.elementAt(2):" + vec.elementAt(2));System.out.println("vec.lastElement():" + vec.lastElement());System.out.println("size:" + vec.size());System.out.println("capacity:" + vec.capacity());System.out.println("vec 2 to 4:" + vec.subList(1, 4));Enumeration enu = vec.elements();while (enu.hasMoreElements()) {System.out.println("nextElement():" + enu.nextElement());Vector retainVec = new Vector();retainVec.add("100");retainVec.add("300");System.out.println("vec.retain():" + vec.retainAll(retainVec));System.out.println("vec:" + vec);String[] arr = (String[]) vec.toArray(new String[0]);for (String str : arr)System.out.println("str:" + str);vec.clear();vec.removeAllElements();System.out.println("vec.isEmpty():" + vec.isEmpty());}}
}

输出结果：

vec:[100, 2, 300, 3, 4, 5]
vec.indexOf(100):0
vec.lastIndexOf(100):0
vec.firstElement():100
vec.elementAt(2):300
vec.lastElement():5
size:6
capacity:10
vec 2 to 4:[2, 300, 3]
nextElement():100
vec.retain():true
vec:[100, 300]
str:100
str:300
vec.isEmpty():true

三、源码解析：

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、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++;     //修改次数+1if (index >= elementCount) {   //删除位置大于容器有效大小throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);}else if (index < 0) {    //位置小于 < 0throw new ArrayIndexOutOfBoundsException(index);}int j = elementCount - index - 1;if (j > 0) {   //从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。//也就是数组元素从j位置往前移System.arraycopy(elementData, index + 1, elementData, index, j);}elementCount--;   //容器中有效组件个数 - 1elementData[elementCount] = null;    //将向量的末尾位置设置为null}

因为Vector底层是使用数组实现的，所以它的操作都是对数组进行操作，只不过其是可以随着元素的增加而动态的改变容量大小，其实现方法是是使用Arrays.copyOf方法将旧数据拷贝到一个新的大容量数组中。Vector的整个内部实现都比较简单，这里就不在重述了。

3、Vector 其他方法源代码：

public class Vector<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{protected Object[] elementData;//对象数组，来存放数据protected int elementCount; //当前的数据数目protected int capacityIncrement; //容量增长private static final long serialVersionUID = -2767605614048989439L; //序列号//构造函数矢量队列初始化大小和增长大小public Vector(int initialCapacity, int capacityIncrement) {super();if (initialCapacity < 0)throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);this.elementData = new Object[initialCapacity];this.capacityIncrement = capacityIncrement;}//构造函数初始化大小public Vector(int initialCapacity) {this(initialCapacity, 0);}//构造函数默认初始化大小10public Vector() {this(10);}//带有集合参数的构造函数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 synchronized void copyInto(Object[] anArray) {System.arraycopy(elementData, 0, anArray, 0, elementCount);}//调整容量大小适合当前矢量队列的大小public synchronized void trimToSize() {modCount++;int oldCapacity = elementData.length;if (elementCount < oldCapacity) {elementData = Arrays.copyOf(elementData, elementCount);}}//增加矢量队列的容量大小public synchronized void ensureCapacity(int minCapacity) {if (minCapacity > 0) {modCount++;ensureCapacityHelper(minCapacity);}}private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious codeif (minCapacity - elementData.length > 0)grow(minCapacity);}private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;private void grow(int minCapacity) {
// overflow-conscious codeint 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) // overflowthrow new OutOfMemoryError();return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :MAX_ARRAY_SIZE;}//调整大小，如果超出了就删掉多余的对象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;}//矢量对象的容量public synchronized int capacity() {return elementData.length;}//矢量队列的大小public synchronized int size() {return elementCount;}//是否为空public synchronized boolean isEmpty() {return elementCount == 0;}//生成Enumeration对象，进行遍历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");}};}//判断是否包含某个对象public boolean contains(Object o) {return indexOf(o, 0) >= 0;}//返回某个对象的下标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;}//最后出现的对象的坐标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;}//返回某个坐标的节点public synchronized E elementAt(int index) {if (index >= elementCount) {throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);}return elementData(index);}//第一个元素public synchronized E firstElement() {if (elementCount == 0) {throw new NoSuchElementException();}return elementData(0);}//最后一个元素public synchronized E lastElement() {if (elementCount == 0) {throw new NoSuchElementException();}return elementData(elementCount - 1);}//对下标为index的元素替换为objpublic synchronized void setElementAt(E obj, int index) {if (index >= elementCount) {throw new ArrayIndexOutOfBoundsException(index + " >= " +elementCount);}elementData[index] = obj;}//删除某个下标的元素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坐标后添加objpublic 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++;}//矢量队列末尾添加元素public synchronized void addElement(E obj) {modCount++;ensureCapacityHelper(elementCount + 1);elementData[elementCount++] = obj;}//删除obj元素public synchronized boolean removeElement(Object obj) {modCount++;int i = indexOf(obj);if (i >= 0) {removeElementAt(i);return true;}return false;}//清空所有元素public synchronized void removeAllElements() {modCount++;
// Let gc do its workfor (int i = 0; i < elementCount; i++)elementData[i] = null;elementCount = 0;}//克隆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 Cloneablethrow new InternalError(e);}}//生成数组public synchronized Object[] toArray() {return Arrays.copyOf(elementData, elementCount);}@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;}@SuppressWarnings("unchecked")E elementData(int index) {return (E) elementData[index];}//得到index的元素public synchronized E get(int index) {if (index >= elementCount)throw new ArrayIndexOutOfBoundsException(index);return elementData(index);}//将index元素替换成elementpublic synchronized E set(int index, E element) {if (index >= elementCount)throw new ArrayIndexOutOfBoundsException(index);E oldValue = elementData(index);elementData[index] = element;return oldValue;}//矢量队列队尾添加元素public synchronized boolean add(E e) {modCount++;ensureCapacityHelper(elementCount + 1);elementData[elementCount++] = e;return true;}//删除对象public boolean remove(Object o) {return removeElement(o);}//在index处添加元素public void add(int index, E element) {insertElementAt(element, index);}//删除index处元素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 workreturn oldValue;}//清空元素public void clear() {removeAllElements();}//判断Vector中是否含有所有的Collectionpublic synchronized boolean containsAll(Collection<?> c) {return super.containsAll(c);}//将Collection添加到矢量队列的队尾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;}//删除包含Collection的元素public synchronized boolean removeAll(Collection<?> c) {return super.removeAll(c);}//删除不存在Collection的元素public synchronized boolean retainAll(Collection<?> c) {return super.retainAll(c);}//在某个index之后追加集合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;}//判断矢量队列是否相同public synchronized boolean equals(Object o) {return super.equals(o);}//返回hashCodepublic synchronized int hashCode() {return super.hashCode();}//public synchronized String toString() {return super.toString();}//切断public synchronized List<E> subList(int fromIndex, int toIndex) {return Collections.synchronizedList(super.subList(fromIndex, toIndex),this);}//删除范围protected synchronized void removeRange(int fromIndex, int toIndex) {modCount++;int numMoved = elementCount - toIndex;System.arraycopy(elementData, toIndex, elementData, fromIndex,numMoved);// Let gc do its workint newElementCount = elementCount - (toIndex-fromIndex);while (elementCount != newElementCount)elementData[--elementCount] = null;}//序列化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();}//迭代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);}public synchronized Iterator<E> iterator() {return new Itr();}private class Itr implements Iterator<E> {int cursor;       // index of next element to returnint lastRet = -1; // index of last element returned; -1 if no suchint expectedModCount = modCount;public boolean hasNext() {
// Racy but within spec, since modifications are checked// within or after synchronization in next/previousreturn 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;}@Overridepublic void forEachRemaining(Consumer<? super E> action) {Objects.requireNonNull(action);synchronized (Vector.this) {final int size = elementCount;int i = cursor;if (i >= size) {return;}@SuppressWarnings("unchecked")final E[] elementData = (E[]) Vector.this.elementData;if (i >= elementData.length) {throw new ConcurrentModificationException();}while (i != size && modCount == expectedModCount) {action.accept(elementData[i++]);}
// update once at end of iteration to reduce heap write trafficcursor = i;lastRet = i - 1;checkForComodification();}}final void checkForComodification() {if (modCount != expectedModCount)throw new ConcurrentModificationException();}}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;}}@Overridepublic synchronized void forEach(Consumer<? super E> action) {Objects.requireNonNull(action);final int expectedModCount = modCount;@SuppressWarnings("unchecked")final E[] elementData = (E[]) this.elementData;final int elementCount = this.elementCount;for (int i=0; modCount == expectedModCount && i < elementCount; i++) {action.accept(elementData[i]);}if (modCount != expectedModCount) {throw new ConcurrentModificationException();}}@Override@SuppressWarnings("unchecked")public synchronized boolean removeIf(Predicate<? super E> filter) {Objects.requireNonNull(filter);
// figure out which elements are to be removed// any exception thrown from the filter predicate at this stage// will leave the collection unmodifiedint removeCount = 0;final int size = elementCount;final BitSet removeSet = new BitSet(size);final int expectedModCount = modCount;for (int i=0; modCount == expectedModCount && i < size; i++) {@SuppressWarnings("unchecked")final E element = (E) elementData[i];if (filter.test(element)) {removeSet.set(i);removeCount++;}}if (modCount != expectedModCount) {throw new ConcurrentModificationException();}// shift surviving elements left over the spaces left by removed elementsfinal boolean anyToRemove = removeCount > 0;if (anyToRemove) {final int newSize = size - removeCount;for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {i = removeSet.nextClearBit(i);elementData[j] = elementData[i];}for (int k=newSize; k < size; k++) {elementData[k] = null;  // Let gc do its work}elementCount = newSize;if (modCount != expectedModCount) {throw new ConcurrentModificationException();}modCount++;}return anyToRemove;}@Override@SuppressWarnings("unchecked")public synchronized void replaceAll(UnaryOperator<E> operator) {Objects.requireNonNull(operator);final int expectedModCount = modCount;final int size = elementCount;for (int i=0; modCount == expectedModCount && i < size; i++) {elementData[i] = operator.apply((E) elementData[i]);}if (modCount != expectedModCount) {throw new ConcurrentModificationException();}modCount++;}@SuppressWarnings("unchecked")@Overridepublic synchronized void sort(Comparator<? super E> c) {final int expectedModCount = modCount;Arrays.sort((E[]) elementData, 0, elementCount, c);if (modCount != expectedModCount) {throw new ConcurrentModificationException();}modCount++;}@Overridepublic Spliterator<E> spliterator() {return new VectorSpliterator<>(this, null, 0, -1, 0);}/** Similar to ArrayList Spliterator */static final class VectorSpliterator<E> implements Spliterator<E> {private final Vector<E> list;private Object[] array;private int index; // current index, modified on advance/splitprivate int fence; // -1 until used; then one past last indexprivate int expectedModCount; // initialized when fence set/** Create new spliterator covering the given  range */VectorSpliterator(Vector<E> list, Object[] array, int origin, int fence,int expectedModCount) {this.list = list;this.array = array;this.index = origin;this.fence = fence;this.expectedModCount = expectedModCount;}private int getFence() { // initialize on first useint hi;if ((hi = fence) < 0) {synchronized(list) {array = list.elementData;expectedModCount = list.modCount;hi = fence = list.elementCount;}}return hi;}public Spliterator<E> trySplit() {int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;return (lo >= mid) ? null :new VectorSpliterator<E>(list, array, lo, index = mid,expectedModCount);}@SuppressWarnings("unchecked")public boolean tryAdvance(Consumer<? super E> action) {int i;if (action == null)throw new NullPointerException();if (getFence() > (i = index)) {index = i + 1;action.accept((E)array[i]);if (list.modCount != expectedModCount)throw new ConcurrentModificationException();return true;}return false;}@SuppressWarnings("unchecked")public void forEachRemaining(Consumer<? super E> action) {int i, hi; // hoist accesses and checks from loopVector<E> lst; Object[] a;if (action == null)throw new NullPointerException();if ((lst = list) != null) {if ((hi = fence) < 0) {synchronized(lst) {expectedModCount = lst.modCount;a = array = lst.elementData;hi = fence = lst.elementCount;}}elsea = array;if (a != null && (i = index) >= 0 && (index = hi) <= a.length) {while (i < hi)action.accept((E) a[i++]);if (lst.modCount == expectedModCount)return;}}throw new ConcurrentModificationException();}public long estimateSize() {return (long) (getFence() - index);}public int characteristics() {return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;}}
}

原文转自：

https://blog.csdn.net/chenssy/article/details/37520981

https://blog.csdn.net/qq924862077/article/details/48039567?utm_source=blogxgwz3