溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
如何用源碼分析Vector，相信很多沒有經驗的人對此束手無策，為此本文總結了問題出現的原因和解決方法，通過這篇文章希望你能解決這個問題。
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
}Vector繼承了AbstractList，實現了List；所以它是一個隊列，支持添加、刪除、修改、遍歷等操作。
Vector實現了RandomAccess接口，支持快速隨機訪問策略。
Vector實現了Cloneable接口，重寫了clone方法，因此可以進行克隆。
Vector實現了Serializable接口，因此可以進行序列化。
Vector的操作是線程安全的
/** 集合最大容量 **/ private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; /** 保存著添加到Vector中的元素 **/ protected Object[] elementData; /** 集合中元素的數量 **/ protected int elementCount; /** 集合增長系數 **/ protected int capacityIncrement;
/** 默認構造函數，初始化容量為10 **/
public Vector() {
this(10);
}
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
public Vector(int initialCapacity, int capacityIncrement) {
if (capacityIncrement < 0) {
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
}
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
/** 通過集合初始化Vector **/
public Vector(Collection<? extends E> c) {
elementData = c.toArray();
elementCount = elementData.length;
if (elementData.getClass() != Object[].class) {
elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}
}添加元素主要有add(E e)、add(int index, E element)、addElement(E obj)、insertElementAt(E obj, int index)以及addAll(Collection<? extends E> c) ######add(E e)
/** 通過synchronized關鍵字實現線程安全 **/
public synchronized boolean add(E e) {
//確保容量足夠
ensureCapacityHelper(elementCount + 1);
//添加元素到集合尾部
elementData[elementCount++] = e;
modCount ++;
return true;
}
private void ensureCapacityHelper(int minCapacity) {
//如果大于數組的容量 通過grow方法擴容
if (minCapacity > elementData.length) {
grow(minCapacity);
}
}
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
//如果自增系數大于0 則每次擴容自增數；否則每次擴容一倍
int newCapacity = oldCapacity + capacityIncrement > 0 ? capacityIncrement : oldCapacity;
//如果擴容一次后 仍然小于所需容量 則直接設置為所需容量
if (newCapacity < minCapacity) newCapacity = minCapacity;
//如果擴容后大于數組允許最大容量 如果所需容量大于數組允許最大容量 則設置為Integer的最大值，否則設置為數組允許的最大容量
if (newCapacity > MAX_ARRAY_SIZE) newCapacity = minCapacity > MAX_ARRAY_SIZE ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
//擴容數組
elementData = Arrays.copyOf(elementData, newCapacity);
}/** 通過insertElementAt方法實現數據的添加及線程安全 **/
public void add(int index, E element) {
insertElementAt(element, index);
}/** Vector自有的方法 與add方法除了返回值幾乎沒有區別 **/
public synchronized void addElement(E obj) {
ensureCapacityHelper(elementCount + 1);
elementData[elementCount ++] = obj;
modCount ++;
}/** 通過synchronized關鍵字實現線程安全 **/
public synchronized void insertElementAt(E obj, int index) {
//判斷index是否越界
if (index > elementCount) throw new ArrayIndexOutOfBoundsException(index + ">" + elementCount);
//確保容量足夠
ensureCapacityHelper(elementCount + 1);
//將index后元素往后移
System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
//添加元素
elementData[index] = obj;
elementCount ++;
modCount ++;
}public synchronized boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
//確保容量足夠
ensureCapacityHelper(elementCount + numNew);
//添加元素
System.arraycopy(a, 0, elementData, elementCount, numNew);
elementCount += numNew;
modCount ++;
return numNew != 0;
}@Override
public synchronized boolean addAll(int index, Collection<? extends E> c) {
//判斷index是否越界
if (index < 0 || index > elementCount) throw new ArrayIndexOutOfBoundsException(index + ">" + elementCount);
Object[] a = c.toArray();
int numNew = a.length;
//確保容量足夠
ensureCapacityHelper(elementCount + numNew);
int needMoved = elementCount - index;
if (needMoved > 0) {
//將index后元素往后移
System.arraycopy(elementData, index, elementData, index + numNew, elementCount - index);
}
//添加元素
System.arraycopy(a, 0, elementData, index, numNew);
elementCount += numNew;
modCount ++;
return numNew != 0;
}移除元素主要有以下幾個方法：
移除單個元素的方法；如：remove(int index)、remove(Object o)、removeElement(Object obj)、removeElementAt(int index)
移除多個元素的方法；如removeAll(Collection<?> c)、retainAll(Collection<?> c)、removeAllElements()
public synchronized E remove(int index) {
//判斷index是否越界
if (index < 0 || index >= elementCount) throw new ArrayIndexOutOfBoundsException(index + ">" + elementCount);
E oldValue = elementData(index);
int needMoved = elementCount - index - 1;
if (needMoved > 0) {
//將index后元素往前移
System.arraycopy(elementData, index + 1, elementData, index, needMoved);
}
elementData[--elementCount] = null;
modCount ++;
return oldValue;
}
/** 查找元素的方法 **/
E elementData(int index) {
return (E) elementData[index];
}//通過removeElement實現元素的移除及線程同步
public boolean remove(Object o) {
return removeElement(o);
}/** 先通過indexOf方法找到元素 如果找到就通過removeElementAt方法移除 沒找到就返回false **/
public synchronized boolean removeElement(Object obj) {
modCount ++;
int i = indexOf(obj);
if (i > 0) {
removeElementAt(i);
return true;
}
return false;
}
@Override
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;
}/** 同上方的remove(int index)方法基本一致 無返回值 **/
public synchronized void removeElementAt(int index) {
if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index + ">" + elementCount);
else if (index < 0) throw new ArrayIndexOutOfBoundsException(index);
int needMoved = elementCount - index - 1;
if (needMoved > 0) {
//將index后元素往前移
System.arraycopy(elementData, index + 1, elementData, index, needMoved);
}
elementData[--elementCount] = null;
modCount ++;
}/** 通過父類AbstractCollection的removeAll實現 **/
public synchronized boolean removeAll(Collection<?> c){
return super.removeAll(c);
}
/** AbstractCollection的removeAll**/
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
boolean modified = false;
Iterator<?> it = iterator();
while (it.hasNext()) {
if (c.contains(it.next())) {
it.remove();
modified = true;
}
}
return modified;
}
/** 通過父類AbstractCollection的retainAll實現 **/
public synchronized boolean retainAll(Collection<?> c) {
return super.retainAll(c);
}
/** AbstractCollection的retainAll**/
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);
boolean modified = false;
Iterator<E> it = iterator();
while (it.hasNext()) {
if (!c.contains(it.next())) {
it.remove();
modified = true;
}
}
return modified;
}/** 移除所有元素 **/
public synchronized void removeAllElements() {
for (int i = 0; i < elementCount; i++) {
elementData[i] = null;
}
elementCount = 0;
modCount ++;
}查找元素主要有get(int index)、elementAt(int index)，兩者方法都通過上方的elementData(int index)方法實現
public E get(int index) {
if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}更新元素主要有set(int index, E element)和setElementAt(E obj, int index)兩個方法，主要是返回值不同。
public synchronized E set(int index, E element) {
if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index);
E e = elementData(index);
elementData[index] = element;
return e;
}public synchronized void setElementAt(E obj, int index) {
if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index);
elementData[index] = obj;
}看完上述內容，你們掌握如何用源碼分析Vector的方法了嗎？如果還想學到更多技能或想了解更多相關內容，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
