ArrayList集合
ArrayList
的底層是數組隊列,相當于動態數組。與 Java 中的數組相比,它的容量能動態增長。在添加大量元素前,應用程序可以使用ensureCapacity
操作來增加 ArrayList 實例的容量。這可以減少遞增式再分配的數量。
ArrayList 繼承于 AbstractList ,實現了 List, RandomAccess, Cloneable, java.io.Serializable 這些接口。
List : 表明它是一個列表,支持添加、刪除、查找等操作,并且可以通過下標進行訪問。
RandomAccess :這是一個標志接口,表明實現這個接口的 List 集合是支持 快速隨機訪問 的。在 ArrayList 中,我們即可以通過元素的序號快速獲取元素對象,這就是快速隨機訪問。
Cloneable :表明它具有拷貝能力,可以進行深拷貝或淺拷貝操作。
Serializable : 表明它可以進行序列化操作,也就是可以將對象轉換為字節流進行持久化存儲或網絡傳輸,非常方便。
ArrayList 和 Vector 的區別
ArrayList 是 List 的主要實現類,底層使用 Object[]存儲,適用于頻繁的查找工作,線程不安全 。Vector 是 List 的古老實現類,底層使用Object[] 存儲,線程安全。
ArrayList 中可以存儲任何類型的對象,包括 null 值。不過,不建議向ArrayList 中添加 null 值, null 值無意義,會讓代碼難以維護比如忘記做判空處理就會導致空指針異常。
核心代碼模擬解讀
- System.arrayCopy()
/*** 復制數組* @param src 源數組* @param srcPos 源數組中的起始位置* @param dest 目標數組* @param destPos 目標數組中的起始位置* @param length 要復制的數組元素的數量*/public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length);
package com.netty.myb.list;import java.util.*;/*** @program: java-study* @description: ArrayList模擬* @author: mengyb* @create: 2025-07-15 14:30**/public class ArrayListDemo<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{/*** 默認的容量*/private static final int DEFAULT_CAPACITY = 10;/*** Shared empty array instance used for empty instances.* 空的數組*/private static final Object[] EMPTY_ELEMENTDATA = {};/*** Shared empty array instance used for default sized empty instances. We* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when* first element is added.*/private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};/*** 存儲元素的數組*/transient Object[] elementData; // non-private to simplify nested class access/*** 數組集合的大小Size*/private int size;public static void main(String[] args) {List<String> list = new ArrayList<>();}public ArrayListDemo(int initialCapacity) {// 指定初始化的容量 則創建該容量的數組if (initialCapacity > 0) {// 創建一個初始的數組 Object[] elementData = new Object[initialCapacity];this.elementData = new Object[initialCapacity];} else if (initialCapacity == 0) {// 初始化容量為0,則建立一個空的數組 Object[] elementData = {};this.elementData = EMPTY_ELEMENTDATA;} else {throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);}}public ArrayListDemo() {// Object[] elementData = {};this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;}public ArrayListDemo(Collection<? extends E> c) {// 將一個集合轉化為 數組 Object[] a = {1,1,1}Object[] a = c.toArray();// 數組的大小 不為0if ((size = a.length) != 0) {// 判斷是否為ArrayListif (c.getClass() == ArrayList.class) {// Object[] elementData = a;elementData = a;} else {// Object[] elementObject = {1,2,3}; 長度為sizeelementData = Arrays.copyOf(a, size, Object[].class);}} else {// replace with empty array.// 如果數組為0 則創建一個空數組 Object[] elementData = {}elementData = EMPTY_ELEMENTDATA;}}@Overridepublic E get(int index) {return null;}@Overridepublic int size() {return size;}/*** 淺拷貝* @return*/public Object clone() {try {// 淺拷貝ArrayListDemo<?> v = (ArrayListDemo<?>) super.clone();// 實現數組的復制,返回復制后的數組v.elementData = Arrays.copyOf(elementData, size);v.modCount = 0;return v;} catch (CloneNotSupportedException e) {// this shouldn't happen, since we are Cloneablethrow new InternalError(e);}}/*** Arrays.copyOf(目標數組, 大小); 將Object[]數組拷貝出來*/public Object[] toArray() {return Arrays.copyOf(elementData, size);}public <T> T[] toArray(T[] a) {if (a.length < size)// Make a new array of a's runtime type, but my contents:return (T[]) Arrays.copyOf(elementData, size, a.getClass());// System.arraycopy(目標數組,從第幾個開始,復制進新數組, 從新數組的第幾個開始, 復制的長度為size)// Object[] a = elementData;System.arraycopy(elementData, 0, a, 0, size);// 新數組的長度 大于 elementData的長度if (a.length > size)a[size] = null;return a;}/*** 獲取數組 通過下標索引獲取指定的元素* @param index index of the element to return* @return*/public E get(int index) {// 檢查 index 是否越界rangeCheck(index);// 從Object[] elementData數組中獲取指定的下標值return elementData(index);}/*** 檢查索引index 是否 超出Object[] elementData的長度* @param index*/private void rangeCheck(int index) {if (index >= size)throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}/*** 根據下標索引從數組中獲取元素* @param index* @return*/@SuppressWarnings("unchecked")E elementData(int index) {return (E) elementData[index];}/*** 新增元素,在數組的最后添加元素* @param e* @return*/public boolean add(E e) {// 擴容 1ensureCapacityInternal(size + 1); // Increments modCount!!// 將Object[] elementData 數組容量+1elementData[size++] = e;return true;}/*** 在指定位置新增元素* @param index 增加元素的索引* @param element*/public void add(int index, E element) {// 1 范圍檢測 判斷是否越界rangeCheckForAdd(index);// 2 擴容ensureCapacityInternal(size + 1); // Increments modCount!!// 3、將原數組復制到新數組中, 將elementData擴容后, index后面的元素 放到擴容后的index+1后System.arraycopy(elementData, index, elementData, index + 1,size - index);// 4、將擴容后,空閑出來的index索引元素 賦值為elementelementData[index] = element;// 5、將統計容量的size+1size++;}// 判斷下標是否越界private void rangeCheckForAdd(int index) {if (index > size || index < 0)throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}/*** 刪除指定元素* @param o 元素* @return*/public boolean remove(Object o) {if (o == null) {// 找到 null 的元素索引for (int index = 0; index < size; index++)if (elementData[index] == null) {fastRemove(index);return true;}} else {// 找到非null元素的索引for (int index = 0; index < size; index++)if (o.equals(elementData[index])) {// 找到刪除元素的下標索引fastRemove(index);return true;}}return false;}/*** 根據下標索引刪除元素* @param index 4*/private void fastRemove(int index) {modCount++;// 數組移動 8-4-1 = 5int numMoved = size - index - 1;if (numMoved > 0)// 將index后的元素復制到 index-1后的位置,最后一個元素需要被刪除System.arraycopy(elementData, index+1, elementData, index,numMoved);// 刪除最后一個元素elementData[--size] = null; // clear to let GC do its work}// 清空元素public void clear() {modCount++;// clear to let GC do its work// 將Object[] 的所有元素設置為nullfor (int i = 0; i < size; i++)elementData[i] = null;size = 0;}/*** 刪除指定范圍的元素* @param fromIndex index of first element to be removed* @param toIndex index after last element to be removed*/protected void removeRange(int fromIndex, int toIndex) {modCount++;int numMoved = size - toIndex;// 將范圍以外的元素,賦值給formIndex開始的位置System.arraycopy(elementData, toIndex, elementData, fromIndex,numMoved);// clear to let GC do its work// 新的數組大小Object[]int newSize = size - (toIndex-fromIndex);for (int i = newSize; i < size; i++) {// 新的數組后的元素設置為nullelementData[i] = null;}size = newSize;}/*** 擴容第一步* @param minCapacity 在原來的size + 1*/private void ensureCapacityInternal(int minCapacity) {// 開始擴容ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));}/*** 擴容 1.1* @param elementData 原數組* @param minCapacity 最小容量 size + 1* @return*/private static int calculateCapacity(Object[] elementData, int minCapacity) {// 判斷當前數組Object[] elementData 是否是 {} 空的if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {// elementData = {}; 在 默認容量10 與 現在的容量 進行比較 獲取最大的那個值return Math.max(DEFAULT_CAPACITY, minCapacity);}// 返回現在的容量 size + 1return minCapacity;}/*** 擴容 1.2 步驟* @param minCapacity DEFAULT_CAPACITY > size + 1 ? 10 : size+1*/private void ensureExplicitCapacity(int minCapacity) {modCount++;// overflow-conscious code// 判斷是否擴容成功if (minCapacity - elementData.length > 0)// 擴容第二布grow(minCapacity);}/*** TODO 數組的最大長度為 Integer.MAX_VALUE-8*/private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;/*** 擴容 2.1* @param minCapacity DEFAULT_CAPACITY > size + 1 ? 10 : size+1*/private void grow(int minCapacity) {// overflow-conscious code// 原容量大小int oldCapacity = elementData.length;// 新容量 = 原容量 + 原容量/2;int newCapacity = oldCapacity + (oldCapacity >> 1);// 新容量 > size + 1;if (newCapacity - minCapacity < 0)// newCapacity = DEFAULT_CAPACITY > size + 1 ? 10 : size+1newCapacity = 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);}/*** 擴容 2.2 newCapacity新容量 超出了 最大值Integer.MAX_VALUE-8 的限制 后處理方案* @param minCapacity DEFAULT_CAPACITY > size + 1 ? 10 : size+1* @return*/private static int hugeCapacity(int minCapacity) {//if (minCapacity < 0) // overflow// 內存溢出throw new OutOfMemoryError();// DEFAULT_CAPACITY > size + 1 ? 10 : size+1 > Integer.MAX_VALUE-8 : Integer.MAX_VALUE : Integer.MAX_VALUE-8// 返回一個新的容量 要不然是 Integer的最大值,要不然返回數組的最大限制return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :MAX_ARRAY_SIZE;}}