首先我們要明白java中的集合Collection,List,ArrayList之間的關係:
ArrayList是具體的實現類,實現了List接口；
List是接口,繼承了Collection接口；
List繼承了Collection接口，但是List是可以重複的並且有序的集合，Collection是不可重複且無序的。
這裏我們先講一下List集合:
List接口不能被構造 也就是我們說的不能創建實例對象 但是我們可以像下面那樣爲List接口創建一個指向自己的對象引用 而ArrayList實現類的實例對象就在這充當了這個指向List接口的對象引用 這也是多態的一種:
List list = new ArrayList();
那麼現在問題來了
爲什麼要用 List list = new ArrayList() 而不用 ArrayList alist = new ArrayList()呢?
問題就在於List接口有多個實現類，現在你用的是ArrayList，也許哪一天你需要換成其它的實現類，如 LinkedList或者Vector等等，這時你只要改變這一行就行了；
List list = new LinkedList(); 其它使用了list地方的代碼根本不需要改動
假設你開始用ArrayList alist = new ArrayList() ，那需要改的地方就很多了，特別是如果你使用了ArrayList實現類特有的方法和屬性。
這樣的好處也是爲了代碼的可維護性 可複用性 可擴展性以及靈活性 再者就是這符合了***里氏代換原則***和***開閉原則***
言歸正傳：我們下面說一下集合的長度爲什麼是不固定的！
我們知道集合的底層其實也是用數組實現的 那麼爲什麼定義集合的時候 是不需要給出size的 而數組在定義的時候就需要給出長度?
首先我們分析一下ArrayList的無參構造方法:
/**
* Constructs an empty list with an initial capacity of ten.
*/
public ArrayList() {
super();
this.elementData = EMPTY_ELEMENTDATA;
}
/**
* Default initial capacity.
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* Shared empty array instance used for empty instances.
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer. Any
* empty ArrayList with elementData == EMPTY_ELEMENTDATA will be expanded to
* DEFAULT_CAPACITY when the first element is added.
*/
private transient Object[] elementData;
我們發現無參的構造方法裏面 this.elementData = EMPTY_ELEMENTDATA; 相當於給集合了一個空的數組 而且上面代碼紫色部分說在第一次給集合添加元素的時候 會把 DEFAULT_CAPACITY 也就是10設置成數組長度。
那麼我們通過ArrayList中的add方法看一看是否是這樣子:
/**
* The size of the ArrayList (the number of elements it contains).
*
* @serial
*/
private int size;
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
//這裏elementData==EMPTY_ELEMENTDATA 也就是上面無參構造方法裏的的賦值, 所以這裏的判斷可以理解爲是否是第一次添加元素時調用此方法
if (elementData == EMPTY_ELEMENTDATA) {
//如果是第一次添加元素 minCapacity應該爲0+1 所以這裏把DEFAULT_CAPACITY也就是10賦值給minCapacity
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
//這裏判斷新添加一個元素以後 長度是否大於當前數組 如果大於則給數組擴容
//如果是第一次添加元素 肯定是true 然後把10傳到grow方法中去
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/**
* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity
*/
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//這裏是給擴容後的數組定義的長度
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果是第一次添加元素 new肯定是小於min的 所以把10賦給newCapacity 用來創建長度爲10的新數組
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
//把原來的數組copy到新數組中 如果是第一次add 則創建了一個長度爲10的數組
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;
}
通過上面的代碼 我們可以發現:
在第一次給集合添加元素的時候，的確會通過add方法及方法內調用的其他方法，創建一個長度爲10的數組。
並且以後每次add的時候，都會先判斷一下 size+1是否超過了數組的長度，如果超過了長度就重新定義一個長度
int newCapacity = oldCapacity + (oldCapacity >> 1) 的數組，然後把舊數組複製到新創建的數組中返回。
解釋一下 int newCapacity = oldCapacity + (oldCapacity >> 1); (oldCapacity >> 1)的意思是oldCapacity轉換成2進制然後右移一位 也就是oldCapacity /2
綜上所述 第一次給集合添加元素的時候 集合中數組的長度會被設置成10 每次數組元素滿了以後 重新給數組設置的長度爲 原數組長度+(原數組長度/2) (這裏跟C#不同,C#中是初始長度爲4 新數組長度=原數組長度*2)