1. Array
Array（數組）是基於索引(index)的數據結構，它使用索引在數組中搜索和讀取數據是很快的。
Array獲取數據的時間復雜度是O(1),但是要刪除數據卻是開銷很大，因為這需要重排數組中的所有數據, (因為刪除數據以后, 需要把后面所有的數據前移)
缺點: 數組初始化必須指定初始化的長度, 否則報錯
例如:
int[] a = new int[4];//推介使用int[] 這種方式初始化
int c[] = {23,43,56,78};//長度：4，索引范圍：[0,3]
2. List
List—是一個有序的集合，可以包含重復的元素，提供了按索引訪問的方式，它繼承Collection。
List有兩個重要的實現類：ArrayList和LinkedList
List是一個接口，不可以實例化, 不能寫成如下：
List<Integer> list = new List<Integer>();//錯誤
- 類繼承關系
3. ArrayList
ArrayList: 可以看作是能夠自動增長容量的數組
ArrayList的toArray方法返回一個數組
ArrayList的asList方法返回一個列表
ArrayList底層的實現是Array, 數組擴容實現
-
新增數據空間判斷
新增數據的時候需要判斷當前是否有空閑空間存儲
-
擴容需要申請新的連續空間
-
把老的數組復制過去
-
新加的內容
-
回收老的數組空間
4. 使用數組長度分配空間性能對比
注意: 長度盡量使用2的冪作為長度, 計算機分配空間大都使用次冪去分配, 減少碎片空間
我們下來看一下代碼:
package javatest;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Jtest
* @Description TODO
* @Author lingxiangxiang
* @Date 4:54 PM
* @Version 1.0
**/
public class Jtest {
public static int length = 1048576; //10的20次冪
public static List<Integer> list1 = new ArrayList<>();
public static List<Integer> list2 = new ArrayList<>(length);
public static void addList(int sign) {
long start = System.currentTimeMillis();
for (int i = 0; i < length; i++) {
if (sign == 0) {
list1.add(sign);
} else {
list2.add(sign);
}
}
long end = System.currentTimeMillis();
System.out.println(sign + " exec time is: " + (end - start));
}
public static void main(String[] args) {
addList(0);
addList(1);
}
}
執行結果:
0 exec time is: 25
1 exec time is: 17
ArrayList在初始化的時候指定長度肯定是要比不指定長度的性能好很多, 這樣不用重復的申請空間, 復制數組, 銷毀老的分配空間了
5. LinkList
LinkList是一個雙鏈表,在添加和刪除元素時具有比ArrayList更好的性能.但在get與set方面弱於ArrayList.當然,這些對比都是指數據量很大或者操作很頻繁。
鏈表不需要連續的空間, 大小不確定
6. 對比
- 時間復雜度
| 操作 | 數組 | 鏈表 |
|---|---|---|
| 隨機訪問 | O(1) | O(N) |
| 頭部插入 | O(N) | O(1) |
| 頭部刪除 | O(N) | O(1) |
| 尾部插入 | O(1) | O(1) |
| 尾部刪除 | O(1) | O(1) |
小結
-
同樣查找, 時間復雜度都是O(N), 但是數組要比鏈表快
因為數組的連續內存, 會有一部分或者全部數據一起進入到CPU緩存, 而鏈表還需要在去內存中根據上下游標查找, CPU緩存比內存塊太多
-
數據大小固定, 不適合動態存儲, 動態添加, 內存為一連續的地址, 可隨機訪問, 查詢速度快
-
鏈表代銷可變, 擴展性強, 只能順着指針的方向查詢, 速度較慢
7. ArrayList的源碼分析
7.1 ArrayList的主要成員變量
private static final int DEFAULT_CAPACITY = 10;
// ArrayList的默認長度是多少
private static final Object[] EMPTY_ELEMENTDATA = {};
// ArrayList的默認空元素鏈表
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// ArrayList存放的數據
transient Object[] elementData; // non-private to simplify nested class access
// ArrayList的長度
private int size;
7.2 ArrayList的構造函數
// 構造一個初始化容量為10的空列表
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 初始化一個指定大小容量的列表
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
// 構造一個包含指定集合的元素列表, 按照它們由集合迭代器返回的順序
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
7.3 擴容機制
ArrayList擴容的核心從ensureCapacityInternal方法說起。可以看到前面介紹成員變量的提到的ArrayList有兩個默認的空數組：
DEFAULTCAPACITY_EMPTY_ELEMENTDATA：是用來使用默認構造方法時候返回的空數組。如果第一次添加數據的話那么數組擴容長度為DEFAULT_CAPACITY=10。
EMPTY_ELEMENTDATA：出現在需要用到空數組的地方，其中一處就是使用自定義初始容量構造方法時候如果你指定初始容量為0的時候就會返回。
// 增加元素的方法
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
//判斷當前數組是否是默認構造方法生成的空數組，如果是的話minCapacity=10反之則根據原來的值傳入下一個方法去完成下一步的擴容判斷
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
//minCapacitt表示修改后的數組容量，minCapacity = size + 1
private void ensureCapacityInternal(int minCapacity) {
//判斷看看是否需要擴容
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
下面談談ensureExplicitCapacity方法（modCount設計到Java的快速報錯機制后面會談到），可以看到如果修改后的數組容量大於當前的數組長度那么就需要調用grow進行擴容，反之則不需要。
//判斷當前ArrayList是否需要進行擴容
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
// int[] a = new int[5]; 數組創建的時候是多大, a.length就等於5
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
最后看下ArrayList擴容的核心方法grow()，下面將針對三種情況對該方法進行解析：
-
當前數組是由默認構造方法生成的空數組並且第一次添加數據。此時minCapacity等於默認的容量（10）那么根據下面邏輯可以看到最后數組的容量會從0擴容成10。而后的數組擴容才是按照當前容量的1.5倍進行擴容；
-
當前數組是由自定義初始容量構造方法創建並且指定初始容量為0。此時minCapacity等於1那么根據下面邏輯可以看到最后數組的容量會從0變成1。這邊可以看到一個嚴重的問題，一旦我們執行了初始容量為0，那么根據下面的算法前四次擴容每次都 +1，在第5次添加數據進行擴容的時候才是按照當前容量的1.5倍進行擴容。
-
當擴容量（newCapacity）大於ArrayList數組定義的最大值后會調用hugeCapacity來進行判斷。如果minCapacity已經大於Integer的最大值（溢出為負數）那么拋出OutOfMemoryError（內存溢出）否則的話根據與MAX_ARRAY_SIZE的比較情況確定是返回Integer最大值還是MAX_ARRAY_SIZE。這邊也可以看到ArrayList允許的最大容量就是Integer的最大值（-2的31次方~2的31次方減1）
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
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:
elementData = Arrays.copyOf(elementData, newCapacity);
}