知識(shí)補(bǔ)充：Arrays.copyOf函數(shù)：

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()在內(nèi)部新建一個(gè)數(shù)組，調(diào)用arrayCopy()將original內(nèi)容復(fù)制到copy中去，并且長度為newLength。返回copy;

繼續(xù)看一下System.arraycopy函數(shù)：

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

src - 源數(shù)組。

srcPos - 源數(shù)組中的起始位置。

dest - 目標(biāo)數(shù)組。

destPos - 目標(biāo)數(shù)據(jù)中的起始位置。

length - 要復(fù)制的數(shù)組元素的數(shù)量。

該方法是用了native關(guān)鍵字，調(diào)用的為C++編寫的底層函數(shù)，可見其為JDK中的底層函數(shù)。

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

public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{ //保存Vector數(shù)據(jù)的數(shù)組 protected Object[] elementData; //實(shí)際數(shù)據(jù)的數(shù)量 protected int elementCount; //容量增長的系數(shù) protected int capacityIncrement; // Vector的序列版本號(hào) private static final long serialVersionUID = -2767605614048989439L; //指定Vector初始大小和增長系數(shù)的構(gòu)造函數(shù) public Vector(int initialCapacity, int capacityIncrement) {super();if (initialCapacity < 0) throw new IllegalArgumentException('Illegal Capacity: '+ initialCapacity);this.elementData = new Object[initialCapacity];this.capacityIncrement = capacityIncrement; } //指定初始容量的構(gòu)造函數(shù) public Vector(int initialCapacity) {this(initialCapacity, 0); } //Vector構(gòu)造函數(shù)，默認(rèn)容量為10 public Vector() {this(10); } //初始化一個(gè)指定集合數(shù)據(jù)的構(gòu)造函數(shù) 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數(shù)組中 public synchronized void copyInto(Object[] anArray) {System.arraycopy(elementData, 0, anArray, 0, elementCount); } //當(dāng)前的數(shù)組中元素個(gè)數(shù)大于記錄的元素個(gè)數(shù)時(shí)，重新賦值給當(dāng)前數(shù)組所記錄的元素 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的改變統(tǒng)計(jì)數(shù)+1 modCount++; ensureCapacityHelper(minCapacity);} } //確定容量的幫助函數(shù)，如果所需容量大于當(dāng)前的容量時(shí)則執(zhí)行擴(kuò)容 private void ensureCapacityHelper(int minCapacity) {// overflow-conscious codeif (minCapacity - elementData.length > 0) grow(minCapacity); } //數(shù)組所允許的最大容量 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; //執(zhí)行擴(kuò)容函數(shù) private void grow(int minCapacity) {// overflow-conscious code//記錄當(dāng)前容量int oldCapacity = elementData.length;//如果擴(kuò)容系數(shù)大于0則新容量等于當(dāng)前容量+擴(kuò)容系數(shù)，如果擴(kuò)容系數(shù)小于等于0則新容量等于當(dāng)前容量的2倍int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);//如果新容量小于當(dāng)前需要的容量，則把需要的容量賦值給需要擴(kuò)容的新容量if (newCapacity - minCapacity < 0) newCapacity = minCapacity; //如果新擴(kuò)容容量大于最大數(shù)組容量，則執(zhí)行巨大擴(kuò)容if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity);elementData = Arrays.copyOf(elementData, newCapacity); } //巨大擴(kuò)容函數(shù)，如果所需容量大于最大數(shù)組容量，則返回int形最大值(2^31 -1),否則返回最大數(shù)組容量 private static int hugeCapacity(int minCapacity) {if (minCapacity < 0) // overflow throw new OutOfMemoryError();return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; } //設(shè)置容量值為newSize，如果newSize大于當(dāng)前容量，則擴(kuò)容，否則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; } //返回當(dāng)前Vector的容量 public synchronized int capacity() {return elementData.length; } //返回Vector元素的個(gè)數(shù) public synchronized int size() {return elementCount; } //Vector元素個(gè)數(shù)是否為0 public synchronized boolean isEmpty() {return elementCount == 0; } //返回Vector元素的Enumeration，Enumeration 接口是Iterator迭代器的“古老版本” //Enumeration接口中的方法名稱難以記憶，而且沒有Iterator的remove()方法。如果現(xiàn)在編寫Java程序，應(yīng)該盡量采用 //Iterator迭代器，而不是用Enumeration迭代器。 //之所以保留Enumeration接口的原因，主要為了照顧以前那些“古老”的程序，那些程序里大量使用Enumeration接口，如果新版 //本的Java里直接刪除Enumeration接口，將會(huì)導(dǎo)致那些程序全部出錯(cuò)。 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中是否包含對(duì)象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中最后一個(gè)元素。 public synchronized E lastElement() {if (elementCount == 0) { throw new NoSuchElementException();}return elementData(elementCount - 1); } // 設(shè)置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后面添加對(duì)象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的克隆。 該副本將包含對(duì)內(nèi)部數(shù)據(jù)數(shù)組的克隆的引用，而不是對(duì)此對(duì)象的原始內(nèi)部數(shù)據(jù)數(shù)組的引用。 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所有元素的數(shù)組 public synchronized Object[] toArray() {return Arrays.copyOf(elementData, elementCount); } // 返回Vector的模板數(shù)組。所謂模板數(shù)組，即可以將T設(shè)為任意的數(shù)據(jù)類型 @SuppressWarnings('unchecked') public synchronized <T> T[] toArray(T[] a) {// 若數(shù)組a的大小 < Vector的元素個(gè)數(shù)；// 則新建一個(gè)T[]數(shù)組，數(shù)組大小是“Vector的元素個(gè)數(shù)”，并將“Vector”全部拷貝到新數(shù)組中if (a.length < elementCount) return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());// 若數(shù)組a的大小 >= Vector的元素個(gè)數(shù)；// 則將Vector的全部元素都拷貝到數(shù)組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); } //設(shè)置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中第一個(gè)出現(xiàn)對(duì)象o的元素 public boolean remove(Object o) {return removeElement(o); } //在index位置添加對(duì)象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; } // 返回兩個(gè)對(duì)象是否相等 public synchronized boolean equals(Object o) {return super.equals(o); } // 計(jì)算哈希值 public synchronized int hashCode() {return super.hashCode(); } // 調(diào)用父類的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的寫入函數(shù) 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;} }}四、總結(jié) Vector實(shí)際上是通過一個(gè)數(shù)組去保存數(shù)據(jù)的。當(dāng)我們構(gòu)造Vecotr時(shí)；若使用默認(rèn)構(gòu)造函數(shù)，則Vector的默認(rèn)容量大小是10。 當(dāng)Vector容量不足以容納全部元素時(shí)，Vector的容量會(huì)增加。若容量增加系數(shù) >0，則將容量的值增加“容量增加系數(shù)”；否則，將容量大小增加一倍。 Vector的克隆函數(shù)，即是將全部元素克隆到一個(gè)數(shù)組中。五、Vector遍歷方式

1. 隨機(jī)訪問遍歷，通過索引值去遍歷

由于Vector實(shí)現(xiàn)了RandomAccess接口，它支持通過索引值去隨機(jī)訪問元素。

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. 通過增強(qiáng)for循環(huán)去遍歷

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

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

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，使用索引的隨機(jī)訪問方式最快，使用迭代器最慢。

到此這篇關(guān)于Java基礎(chǔ)之容器Vector詳解的文章就介紹到這了,更多相關(guān)java容器Vector內(nèi)容請(qǐng)搜索好吧啦網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持好吧啦網(wǎng)！