知識補充：Arrays.copyOf函數：

public static int[] copyOf(int[] original, int newLength) { int[] copy = new int[newLength]; System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }

可見copyOf()在內部新建一個數組，調用arrayCopy()將original內容復制到copy中去，并且長度為newLength。返回copy;

繼續看一下System.arraycopy函數：

public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);

src - 源數組。

srcPos - 源數組中的起始位置。

dest - 目標數組。

destPos - 目標數據中的起始位置。

length - 要復制的數組元素的數量。

該方法是用了native關鍵字，調用的為C++編寫的底層函數，可見其為JDK中的底層函數。

public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable Vector類實現了一個可增長的對象數組，內部是以動態數組的形式來存儲數據的。 Vector具有數組所具有的特性、通過索引支持隨機訪問、所以通過隨機訪問Vector中的元素效率非常高、但是執行插入、刪除時效率比較低下。 繼承了AbstractList,此類提供 List 接口的骨干實現，以最大限度地減少實現”隨機訪問”數據存儲（如數組）支持的該接口所需的工作.對于連續的訪問數據（如鏈表），應優先使用 AbstractSequentialList，而不是此類. 實現了List接口,意味著Vector元素是有序的,可以重復的,可以有null元素的集合. 實現了RandomAccess接口標識著其支持隨機快速訪問,實際上,我們查看RandomAccess源碼可以看到,其實里面什么都沒有定義.因為ArrayList底層是數組,那么隨機快速訪問是理所當然的,訪問速度O(1). 實現了Cloneable接口,標識著可以它可以被復制.注意,ArrayList里面的clone()復制其實是淺復制 實現了Serializable 標識著集合可被序列化。三、Vector源碼

public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{ //保存Vector數據的數組 protected Object[] elementData; //實際數據的數量 protected int elementCount; //容量增長的系數 protected int capacityIncrement; // Vector的序列版本號 private static final long serialVersionUID = -2767605614048989439L; //指定Vector初始大小和增長系數的構造函數 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); } //Vector構造函數，默認容量為10 public 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); } //將Vector全部元素拷貝到anArray數組中 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);} } //確定Vector的容量 public synchronized void ensureCapacity(int minCapacity) {if (minCapacity > 0) { // 將Vector的改變統計數+1 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 code//記錄當前容量int oldCapacity = elementData.length;//如果擴容系數大于0則新容量等于當前容量+擴容系數，如果擴容系數小于等于0則新容量等于當前容量的2倍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); } //巨大擴容函數，如果所需容量大于最大數組容量，則返回int形最大值(2^31 -1),否則返回最大數組容量 private static int hugeCapacity(int minCapacity) {if (minCapacity < 0) // overflow throw new OutOfMemoryError();return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; } //設置容量值為newSize，如果newSize大于當前容量，則擴容，否則newSize以后的所有元素置null 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的容量 public synchronized int capacity() {return elementData.length; } //返回Vector元素的個數 public synchronized int size() {return elementCount; } //Vector元素個數是否為0 public synchronized boolean isEmpty() {return elementCount == 0; } //返回Vector元素的Enumeration，Enumeration 接口是Iterator迭代器的“古老版本” //Enumeration接口中的方法名稱難以記憶，而且沒有Iterator的remove()方法。如果現在編寫Java程序，應該盡量采用 //Iterator迭代器，而不是用Enumeration迭代器。 //之所以保留Enumeration接口的原因，主要為了照顧以前那些“古老”的程序，那些程序里大量使用Enumeration接口，如果新版 //本的Java里直接刪除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'); }}; } //返回Vector中是否包含對象o public boolean contains(Object o) {return indexOf(o, 0) >= 0; } // 查找并返回元素(o)在Vector中的索引值 public int indexOf(Object o) {return indexOf(o, 0); } // 從index位置開始向后查找元素(o)。 // 若找到，則返回元素的索引值；否則，返回-1 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)。并返回元素的索引 public synchronized int lastIndexOf(Object o) {return lastIndexOf(o, elementCount-1); } // 從index位置開始向前查找元素(o)。 // 若找到，則返回元素的索引值；否則，返回-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; } // 返回Vector中index位置的元素。 // 若index越界，則拋出異常 public synchronized E elementAt(int index) {if (index >= elementCount) { throw new ArrayIndexOutOfBoundsException(index + ' >= ' + elementCount);}return elementData(index); } // 返回Vector中第0位置的元素。 public synchronized E firstElement() {if (elementCount == 0) { throw new NoSuchElementException();}return elementData(0); } // 返回Vector中最后一個元素。 public synchronized E lastElement() {if (elementCount == 0) { throw new NoSuchElementException();}return elementData(elementCount - 1); } // 設置index位置的元素值為obj public synchronized void setElementAt(E obj, int index) {if (index >= elementCount) { throw new ArrayIndexOutOfBoundsException(index + ' >= ' + elementCount);}elementData[index] = obj; } //刪除index位置處的元素 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位置插入元素obj 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++; } //在vector后面添加對象obj public synchronized void addElement(E obj) {modCount++;ensureCapacityHelper(elementCount + 1);elementData[elementCount++] = obj; } // 在Vector中查找并刪除元素obj。 // 成功的話，返回true；否則，返回false。 public synchronized boolean removeElement(Object obj) {modCount++;int i = indexOf(obj);if (i >= 0) { removeElementAt(i); return true;}return false; } //刪除Vector中所有元素 public synchronized void removeAllElements() {modCount++;// Let gc do its workfor (int i = 0; i < elementCount; i++) elementData[i] = null;elementCount = 0; } //返回Vector的克隆。 該副本將包含對內部數據數組的克隆的引用，而不是對此對象的原始內部數據數組的引用。 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(e);} } //返回包含Vector所有元素的數組 public synchronized Object[] toArray() {return Arrays.copyOf(elementData, elementCount); } // 返回Vector的模板數組。所謂模板數組，即可以將T設為任意的數據類型 @SuppressWarnings('unchecked') public synchronized <T> T[] toArray(T[] a) {// 若數組a的大小 < Vector的元素個數；// 則新建一個T[]數組，數組大小是“Vector的元素個數”，并將“Vector”全部拷貝到新數組中if (a.length < elementCount) return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());// 若數組a的大小 >= Vector的元素個數；// 則將Vector的全部元素都拷貝到數組a中。System.arraycopy(elementData, 0, a, 0, elementCount);if (a.length > elementCount) a[elementCount] = null;return a; } // Positional Access Operations @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處的元素為element，并返回被替換掉的元素 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末尾添加元素 public synchronized boolean add(E e) {modCount++;ensureCapacityHelper(elementCount + 1);elementData[elementCount++] = e;return true; } //移除Vector中第一個出現對象o的元素 public boolean remove(Object o) {return removeElement(o); } //在index位置添加對象element 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; } // 清空Vector public void clear() {removeAllElements(); } // Bulk Operations // 返回Vector是否包含集合c public synchronized boolean containsAll(Collection<?> c) {return super.containsAll(c); } //在Vector末尾添加集合c 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的全部元素 public synchronized boolean removeAll(Collection<?> c) {return super.removeAll(c); } // 刪除“非集合c中的元素” public synchronized boolean retainAll(Collection<?> c) {return super.retainAll(c); } //在index位置添加集合c中的元素 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); } // 計算哈希值 public synchronized int hashCode() {return super.hashCode(); } // 調用父類的toString() public synchronized String toString() {return super.toString(); } // 獲取Vector中fromIndex(包括)到toIndex(不包括)的子集 public synchronized List<E> subList(int fromIndex, int toIndex) {return Collections.synchronizedList(super.subList(fromIndex, toIndex), this); } // 刪除Vector中fromIndex到toIndex的元素 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; } // java.io.Serializable的寫入函數 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/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;}@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;} } @Override public 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') @Override public 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++; } @Override public 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 use int 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 loop Vector<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; }}else a = 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;} }}四、總結 Vector實際上是通過一個數組去保存數據的。當我們構造Vecotr時；若使用默認構造函數，則Vector的默認容量大小是10。 當Vector容量不足以容納全部元素時，Vector的容量會增加。若容量增加系數 >0，則將容量的值增加“容量增加系數”；否則，將容量大小增加一倍。 Vector的克隆函數，即是將全部元素克隆到一個數組中。五、Vector遍歷方式

1. 隨機訪問遍歷，通過索引值去遍歷

由于Vector實現了RandomAccess接口，它支持通過索引值去隨機訪問元素。

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

2. 通過迭代器遍歷。即通過Iterator去遍歷

Integer value = null;Iterator<Integer> iterator = vec.iterator(); while (iterator.hasNext()) { value = iterator.next(); }

3. 通過增強for循環去遍歷

Integer value = null;for (Integer integ:vec) { value = integ;}

4. 通過Enumeration遍歷

Integer value = null;Enumeration enu = vec.elements();while (enu.hasMoreElements()) { value = (Integer)enu.nextElement();}

測試這些遍歷方式效率的代碼如下：

public class Test { public static void main(String[] args) {Vector<Integer> vector = new Vector<>();for (int i = 0; i < 100000; i++) vector.add(i);iteratorThroughRandomAccess(vector);iteratorThroughIterator(vector);iteratorThroughFor2(vector);iteratorThroughEnumeration(vector); } public static void iteratorThroughRandomAccess(List list) {long startTime, endTime;startTime = System.currentTimeMillis();for (int i = 0; i < list.size(); i++) {}endTime = System.currentTimeMillis();long time = endTime - startTime;System.out.println('iteratorThroughRandomAccess：' + time + ' ms'); } public static void iteratorThroughIterator(List list) {long startTime, endTime;startTime = System.currentTimeMillis();Iterator<Integer> iterator = list.iterator();while (iterator.hasNext()) { iterator.next();}endTime = System.currentTimeMillis();long time = endTime - startTime;System.out.println('iteratorThroughIterator：' + time + ' ms'); } public static void iteratorThroughFor2(List list) {long startTime, endTime;startTime = System.currentTimeMillis();for (Object o : list) {}endTime = System.currentTimeMillis();long time = endTime - startTime;System.out.println('iteratorThroughFor2：' + time + ' ms'); } public static void iteratorThroughEnumeration(Vector vec) {long startTime, endTime;startTime = System.currentTimeMillis();for (Enumeration enu = vec.elements(); enu.hasMoreElements(); ) { enu.nextElement();}endTime = System.currentTimeMillis();long time = endTime - startTime;System.out.println('iteratorThroughEnumeration：' + time + ' ms'); }}

輸出如下：

iteratorThroughRandomAccess：3 msiteratorThroughIterator：6 msiteratorThroughFor2：5 msiteratorThroughEnumeration：5 ms

所以：遍歷Vector，使用索引的隨機訪問方式最快，使用迭代器最慢。

到此這篇關于Java基礎之容器Vector詳解的文章就介紹到這了,更多相關java容器Vector內容請搜索好吧啦網以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持好吧啦網！