java基礎之ArrayList和Vector的主要區別;
阿新 • • 發佈:2018-12-25
List介面下一共實現了三個類:ArrayList,Vector,LinkedList。
LinkedList主要保持資料的插入順序的時候使用,採用連結串列結構。
ArrayList,Vector主要區別為以下幾點:
(1):Vector是執行緒安全的,原始碼中有很多的synchronized可以看出,而ArrayList不是。導致Vector效率無法和ArrayList相比;
(2):ArrayList和Vector都採用線性連續儲存空間,當儲存空間不足的時候,ArrayList預設增加為原來的50%,Vector預設增加為原來的一倍;
(3):Vector可以設定capacityIncrement,而ArrayList不可以,從字面理解就是capacity容量,Increment增加,容量增長的引數。
原始碼分析:
首先看看構造器:
ArrayList:三個
/**
* Constructs an empty list with an initial capacity of ten.
* 構造一個預設初始容量為10的list
*/
public ArrayList() {
super();
this.elementData = EMPTY_ELEMENTDATA;
}
/**
* 構造一個指定預設長度的list initialCapacity 不能小於0;
* Constructs an empty list with the specified initial capacity.
*
* @param initialCapacity the initial capacity of the list
* @throws IllegalArgumentException if the specified initial capacity
* is negative
*/
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: " +
initialCapacity);
this.elementData = new Object[initialCapacity];
}
/** 構造一個包含collection 元素的list
* Constructs a list containing the elements of the specified
* collection, in the order they are returned by the collection's
* iterator.
*
* @param c the collection whose elements are to be placed into this list
* @throws NullPointerException if the specified collection is null
*/
public ArrayList(Collection<? extends E> c) {
...
}
Vector:四個
//構造一個指定預設長度的list
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
//構造一個預設初始容量為10的list
public Vector() {
this(10);
}
//構造一個包含collection 元素的list
public Vector(Collection<? extends E> c) {
...
}
//區別在於可以設定capacityIncrement
public Vector(int initialCapacity, int capacityIncrement) {
super();
...
}
vector多了一個public Vector(int initialCapacity, int capacityIncrement)構造器,可以設定容量增長,arraylist是沒有的。
主要新增原始碼分析
ArrayList類:
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
modCount++;
// overflow-conscious code
//如果新增一個元素之後,新容器的大小大於容器的容量,那麼就無法存值了,需要擴充空間
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1); //擴充的空間增加原來的50%(即是原來的1.5倍)
if (newCapacity - minCapacity < 0) //如果容器擴容之後還是不夠,那麼幹脆直接將minCapacity設為容器的大小
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0) //如果擴充的容器太大了的話,那麼就執行hugeCapacity
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
Vector類:
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
/**
這個擴容需要做個判斷:如果容量增量初始化的不是0,即使用的public Vector(int initialCapacity,int capacityIncrement)
構造方法進行的初始化,那麼擴容的容量是(oldCapacity+capacityIncrement),就是原來的容量加上容量增量的值;
如果沒有設定容量增量,那麼擴容後的容量就是(oldCapacity+oldCapacity),就是原來容量的二倍。
**/
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}