天天看點
傳回

(一)ArrayList集合源碼解析

一、ArrayList的集合特點

問題 結      論
ArrayList是否允許空 允許
ArrayList是否允許重複資料 允許
ArrayList是否有序 有序
ArrayList是否線程安全 非線程安全

二、ArrayList的原理

　　ArrayList底層是一個Object[] elementData數組，能夠實作動态擴容，增減。

　　從源碼看ArrayList實作了RandomAccess, Cloneable,Serializable接口，RandomAccess用于快速存取提高循環的效率。Cloneable該接口可以實作對象的克隆方法。Serializable可以進行序列化，序列化是将對象的狀态資訊轉換為可以存儲或傳輸的形式的過程。

三、源碼解析

1.屬性和構造方法

　　源碼解析主要是從集合從增加元素，删除元素，查詢元素，以及修改元素這幾個常用方法進行解析。

  • ArrayList屬性 
1 transient Object[] elementData;//定義一個elementData數組
2 private int size;//size是數組大小實作數組增減size進行增減
  • ArrayList無參構造方法 
1     /**
2      * Constructs an empty list with an initial capacity of ten.
3      */
4     public ArrayList() {
5         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//将elementData進行初始化elementData也是個Object[]類型。空的Object[]會給預設大小10
6     }
7     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
  • ArrayList有參構造方法 
1   public ArrayList(int initialCapacity) {
 2         if (initialCapacity > 0) {
 3             this.elementData = new Object[initialCapacity];//将自定義的容量大小當成初始化elementData的大小
 4         } else if (initialCapacity == 0) {
 5             this.elementData = EMPTY_ELEMENTDATA;//為0直接進行初始化
 6         } else {
 7             throw new IllegalArgumentException("Illegal Capacity: "+
 8                                                initialCapacity);//判斷如果自定義大小的容量小于0，則報下面這個非法資料異常
 9         }
10     }
  • ArrayList(Collection<? extends E> c)構造方法 
1 //就是将個Collection轉換為ArrayList
 2 public ArrayList(Collection<? extends E> c) {
 3         elementData = c.toArray();
 4         if ((size = elementData.length) != 0) {
 5             // c.toArray might (incorrectly) not return Object[] (see 6260652)
 6             if (elementData.getClass() != Object[].class)//進行對象校驗
 7                 elementData = Arrays.copyOf(elementData, size, Object[].class);
 8         } else {
 9             // replace with empty array.
10             this.elementData = EMPTY_ELEMENTDATA;
11         }
12     }

2.add()方法

  1. add確定數組已使用長度（size）， size+1確定之後足夠存下 下一個資料。
  2. 如果目前數組已使用長度（size）加1後的大于目前的數組長度，則調用grow方法，增長數組，grow方法會将目前數組的長度變為原來容量的1.5倍。
  3. 當第一次添加元素的時候this.size+1 的值是1，是以第一次添加的時候會将目前elementData數組的長度變為10。
  4. 新增的資料有地方存儲之後，則将新元素添加到位于size的位置上。
  5. 傳回添加成功布爾值。 
1    public boolean add(E e) {
2         ensureCapacityInternal(size + 1);  // Increments modCount!!  确定内部容量是否夠了
3         elementData[size++] = e;//指派
4         return true;
5     }

　　從源碼看add方法就是很正常的進行指派的操作，這裡ensureCapacityInternal是數組的核心下面進行詳細介紹。

1     private static int calculateCapacity(Object[] elementData, int minCapacity) {
2         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
3             return Math.max(DEFAULT_CAPACITY, minCapacity);
4         }
5         return minCapacity;
6     }
//確定添加的元素有地方存儲，當第一次添加元素的時候this.size+1 的值是1，是以第一次添加的時候會将目前elementData數組的長度變為10：

　　數組擴容條件判斷:目前所需的數組最小長度與數組的長度對比，如果大于0，則增長數組長度。

1     private void ensureExplicitCapacity(int minCapacity) {
2         modCount++;
3 
4         // overflow-conscious code
5         if (minCapacity - elementData.length > 0)
6             grow(minCapacity);
7     }

　　數組擴容:

1 private void grow(int minCapacity) {
 2         // overflow-conscious code
 3         int oldCapacity = elementData.length;  //将擴充前的elementData大小給oldCapacity
 4         int newCapacity = oldCapacity + (oldCapacity >> 1);//newCapacity就是1.5倍的oldCapacity
 5         if (newCapacity - minCapacity < 0)//elementData就空數組的時候，length=0，那麼oldCapacity=0，newCapacity=0判斷成立，初始化elementData的大小了，就是為10.
 6             newCapacity = minCapacity;
 7         if (newCapacity - MAX_ARRAY_SIZE > 0)//如果newCapacity超過了最大的容量限制，就調用hugeCapacity，也就是将能給的最大值給newCapacity
 8             newCapacity = hugeCapacity(minCapacity);
 9         // minCapacity is usually close to size, so this is a win:
10     //新的容量大小已經确定好了，就copy數組，改變容量大小咯。
11         elementData = Arrays.copyOf(elementData, newCapacity);
12     }

　　hugeCapacity()用來賦最大值。

1 //這個就是上面用到的方法
 2     private static int hugeCapacity(int minCapacity) {
 3         if (minCapacity < 0) // overflow
 4             throw new OutOfMemoryError();
 5 　　//如果minCapacity都大于MAX_ARRAY_SIZE，那麼就Integer.MAX_VALUE傳回，反之将MAX_ARRAY_SIZE傳回。
 6 　　//Integer.MAX_VALUE:2147483647   MAX_ARRAY_SIZE：2147483639  也就是說最大也就能給到第一個數值。還是超過了這個限制，就要溢出了。相當于arraylist給了兩層防護。
 7         return (minCapacity > MAX_ARRAY_SIZE) ?
 8             Integer.MAX_VALUE :
 9             MAX_ARRAY_SIZE;
10     }

3.void add(int，E)；在特定位置添加元素，也就是插入元素

　　在制定位置指派，主要進行以下步驟，arryList集合的核心是arraycopy這個，這個後面具體介紹。

  1. 判斷索引有沒有越界
  2. 自增修改次數
  3. 将指定位置（index）上的元素儲存到oldValue
  4. 将指定位置（index）上的元素都往前移動一位
  5. 将最後面的一個元素置空，好讓垃圾回收器回收
  6. 将原來的值oldValue傳回 
1 public void add(int index, E element) {
 2         rangeCheckForAdd(index);//校驗。
 3         ensureCapacityInternal(size + 1);  // Increments modCount!!
 4 //這個方法就是用來在插入元素之後，要将index之後的元素都往後移一位，
 5         System.arraycopy(elementData, index, elementData, index + 1,
 6                          size - index);
 7 //在目标位置上存放元素
 8         elementData[index] = element;
 9         size++;//size增加1
10     }　　

4.remove(int)：通過删除指定位置上的元素

　　 remove執行的方法如下:

  1. 判斷索引有沒有越界
  2. 自增修改次數
  3. 将指定位置（index）上的元素儲存到oldValue
  4. .将指定位置（index）上的元素都往前移動一位
  5. 将最後面的一個元素置空
  6. 将原來的值oldValue傳回 
1 public E remove(int index) {
 2         rangeCheck(index);//檢查
 3         modCount++;//這個作用很多，比如用來檢測快速失敗(failfast)的一種标志。
 4         E oldValue = elementData(index);//通過索引直接找到該元素
 5         int numMoved = size - index - 1;//計算要移動的位數。
 6         if (numMoved > 0)
 7 　　　　　　//這個方法也已經解釋過了，就是用來移動元素的。
 8             System.arraycopy(elementData, index+1, elementData, index,
 9                              numMoved);
10 　　　　//将--size上的位置指派為null，讓gc回收它。
11         elementData[--size] = null; // clear to let GC do its work
12　　　　 //傳回删除的元素。
13         return oldValue;
14     }

 5.System.arrayCopy這個是數組的擴容的核心api

如圖屬性詳解:

參數 說明
src 原數組
srcPos 原數組
dest 目标數組
destPos 目标數組的起始位置
length 要複制的數組元素的數目

 1 public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)//這個是native方法 

具體使用請檢視這個案例:

int data[] = new int[]{1, 2, 3, 4};
int bigdata[] = new int[6];
System.arraycopy(data, 0, bigdata, 0, 4);
結果：{1,2,3,4,0,0}
如圖所示：
(一)ArrayList集合源碼解析

四、總結:

  1. arrayList可以存放null。
  2. arrayList本質上就是一個elementData數組。
  3. arrayList中removeAll(collection c)和clear()的差別就是removeAll可以删除批量指定的元素，而clear是删除集合中的全部元素。
  4. arrayList由于本質是數組，是以它在資料的查詢方面會很快，而在插入删除這些方面，性能下降很多。
  5. arrayList實作了RandomAccess，是以在周遊它的時候推薦使用for循環。
  6. arrayList的實質是System.arraycopy方法，arraycopy其實是淺拷貝。
上一篇: Navicat連接配接oracle失敗：Error - OCI_INVALID_HANDLE
下一篇: Navicat prmium 12.1.8版對象資訊在右邊