閱讀Vector原始碼記錄的一些筆記
阿新 • • 發佈：2018-12-20
在多執行緒的情況下，ArrayList和LinkedList都是執行緒不安全的，Vector是執行緒安全的，ArrayList是基於陣列實現的，LinkedList是基於雙向連結串列實現，而Vector的實現也是基於陣列的，從資料結構來看，Vector和ArrayList應該很像，實時也是如此，基本上兩者的實現邏輯是一樣的，只是Vector的大部分方法為了保證其在併發環境下安全性，都會加上關鍵字synchronized關鍵字，所以相對於ArrayList來說，Vector的效率更低。
一、構造方法和一些成員變數
1、成員變數
protected Object[] elementData;// 儲存資料用的陣列 2、無參構造方法
無參構造方法初始化的時候預設長度是10
public Vector() {
this(10);
}
3、指定長度的構造方法
此時每次擴容的容量值預設為0
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
4、指定初始化長度和每次擴容的容量的構造方法
以上兩個構造方法，最終都是呼叫了這個構造方法來實現初始化
public 5、根據給定的集合初始化Vector
像ArrayList、LinkedList和Vector在依照給定的集合構造的時候，都會先把集合轉化為陣列，然後再進行操作
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);
}
二、增
1、在尾部新增一個元素
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
private void ensureCapacityHelper(int minCapacity) {
if (minCapacity - elementData.length > 0)// 是否需要擴容
grow(minCapacity);
}
// 擴容
private void grow(int minCapacity) {
int oldCapacity = elementData.length;// 原陣列的長度
// 如果指定的擴容的值，就按照指定值擴容，否則就擴大為原來的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);// 把舊陣列中的資料放到新陣列中
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow 溢位了
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
2、在特定位置增加元素
public void add(int index, E element) {
insertElementAt(element, index);
}
public synchronized void insertElementAt(E obj, int index) {
modCount++;
if (index > elementCount) {// 校驗index是否合法
throw new ArrayIndexOutOfBoundsException(index
+ " > " + elementCount);
}
ensureCapacityHelper(elementCount + 1);// 校驗是否需要擴容
// 把index位置以及其後的資料後移
System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
elementData[index] = obj;// 賦值
elementCount++;
}
3、在尾部追加一個集合的元素
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;
}
4、在特定位置新增一個集合的元素
大致就是把index以及其後的元素往後移動足夠的位置（numNew），然後用集合中的元素覆蓋index位置到index + numNew位置上的資料
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;
}
三、刪
1、刪除特定位置的元素
public synchronized E remove(int index) {
modCount++;
if (index >= elementCount)// index超出了範圍直接拋異常
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;
}
2、移除特定的元素
public boolean remove(Object o) {
return removeElement(o);
}
public synchronized boolean removeElement(Object obj) {
modCount++;
int i = indexOf(obj);// 獲取此元素的位置
if (i >= 0) {
removeElementAt(i);// 刪除特定位置的元素
return true;
}
return false;
}
public int indexOf(Object o) {
return indexOf(o, 0);
}
public synchronized int indexOf(Object o, int index) {
// 分o是否為null兩種情況去匹配元素，如果找到了就返回此元素的索引，否則返回-1
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;
}
3、移除所有的元素
迴圈把所有的元素都置空
public void clear() {
removeAllElements();
}
public synchronized void removeAllElements() {
modCount++;
// Let gc do its work
for (int i = 0; i < elementCount; i++)
elementData[i] = null;
elementCount = 0;
}
四、改
public synchronized E set(int index, E element) {
if (index >= elementCount)// 校驗index的合法性
throw new ArrayIndexOutOfBoundsException(index);
// 獲取原值
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;// 返回原值
}
五、查
public synchronized E get(int index) {
if (index >= elementCount)// 校驗index的合法性
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}
六、其他方法
1、長度
public synchronized int size() {
return elementCount;// 增刪都在維護這個表示長度的值，所以直接取就行了
}
2、是否是空集合
public synchronized boolean isEmpty() {
return elementCount == 0;//長度為0就表示空，沒元素
}
3、是否包含特定元素
public boolean contains(Object o) {
return indexOf(o, 0) >= 0;
}
七、遍歷
三種最常用的遍歷方法
public void testVector2(){
List<String> vector = new Vector();
vector.add("a");
vector.add("b");
vector.add("c");
vector.add("d");
for(int i = 0; i < vector.size(); i ++){
System.out.println(vector.get(i));
}
for(String str : vector){
System.out.println(str);
}
Iterator<String> iterator = vector.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}