private static final long serialVersionUID = 8683452581122892189L;//唯一序列號ID
private static final int DEFAULT_CAPACITY = 10;//jdk7之前初始容量為10，類似餓漢式，jdk8以后初始容量為0，類似懶漢式
private static final Object[] EMPTY_ELEMENTDATA = https://www.cnblogs.com/Justhis610/p/{};//有參構造且傳入大小為0時的空陣列
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = https://www.cnblogs.com/Justhis610/p/{};//無參構造的空陣列
transient Object[] elementData; //實際存盤元素的陣列
private int size;//實際存盤的元素個數
//建構式
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {//懶漢式
this.elementData = https://www.cnblogs.com/Justhis610/p/new Object[initialCapacity];
} else if (initialCapacity == 0) {//餓漢式
this.elementData =https://www.cnblogs.com/Justhis610/p/ EMPTY_ELEMENTDATA;
} else {//傳入的初始容量小于0，非法，拋出例外
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
public ArrayList() {
this.elementData =https://www.cnblogs.com/Justhis610/p/ DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
public ArrayList(Collection<? extends E> c) {
//傳入一個集合，首先轉換為Object陣列，陣列長度不為0時，如果傳入的集合時ArrayList，那么直接賦值底層陣列，否則復制底層陣列，如果長度為0，那么類似有參構造方法引數為0的情況，
Object[] a = c.toArray();
if ((size = a.length) != 0) {
if (c.getClass() == ArrayList.class) {
elementData = a;
} else {
elementData = Arrays.copyOf(a, size, Object[].class);
}
} else {
// replace with empty array.
elementData =https://www.cnblogs.com/Justhis610/p/ EMPTY_ELEMENTDATA;
}
}
public void trimToSize() { //modCount是父抽象類AbstractList中的一個持久化變數，記錄了ArrayList結構變化的次數， modCount++;
//如果當前元素個數小于元素陣列的長度時，元素陣列會根據元素個數是否為0被修改位空陣列或者當前陣列size的copy， if (size < elementData.length) { elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size); } } public void ensureCapacity(int minCapacity) { //如果要求的最小容量大于當前元素陣列的長度，且元素陣列非慷訓者要求的最小容量大于初始容量，那么就進行結構修改，使用增長，增長到最小容量， if (minCapacity > elementData.length && !(elementData =https://www.cnblogs.com/Justhis610/p/= DEFAULTCAPACITY_EMPTY_ELEMENTDATA && minCapacity <= DEFAULT_CAPACITY)) { modCount++; grow(minCapacity); } } private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;//最大元素陣列容量為2^31-9， private Object[] grow(int minCapacity) { //增長的有參方法，將元素陣列復制為一個新陣列，長度為最小容量， return elementData =https://www.cnblogs.com/Justhis610/p/ Arrays.copyOf(elementData, newCapacity(minCapacity)); } private Object[] grow() { //增長的無參構造方法，回傳一個新陣列，長度為當前元素個數+1， return grow(size + 1); } private int newCapacity(int minCapacity) { //newCapacity(min)是自動擴容方法，獲取元素陣列的長度為舊的容量，將新容量設定為舊容量的1.5倍，如果舊容量為0，那么替換為無參構造方法的空陣列，如果擴容的長度溢位，那么拋出超出記憶體例外，自動擴容回傳擴容后的長度， //如果新容量是合法的，那么判斷是否小于等于最大陣列長度，如果是則回傳新長度，否則回傳呼叫hugeCapacity（min）方法的結果，
// overflow-conscious code int oldCapacity = elementData.length; int newCapacity = oldCapacity + (oldCapacity >> 1); if (newCapacity - minCapacity <= 0) { if (elementData =https://www.cnblogs.com/Justhis610/p/= DEFAULTCAPACITY_EMPTY_ELEMENTDATA) return Math.max(DEFAULT_CAPACITY, minCapacity); if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return minCapacity; } return (newCapacity - MAX_ARRAY_SIZE <= 0) ? newCapacity : hugeCapacity(minCapacity); } private static int hugeCapacity(int minCapacity) { //如果形參即原來長度就溢位的話，就拋出超出記憶體例外，否則判斷原來的大小和最大陣列記憶體的長度，回傳2^31-1或2^31-9， if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; }
public int size() {
//回傳實際元素個數
return size;
}
public boolean isEmpty() {
//判斷實際元素個數是否為0
return size == 0;
}
public boolean contains(Object o) {
//查找元素o在陣列中第一次出現的下標，如果為-1就不存在，
return indexOf(o) >= 0;
}
public int indexOf(Object o) {
//呼叫indexOfRange(查找物件，0，實際元素個數)
return indexOfRange(o, 0, size);
}
int indexOfRange(Object o, int start, int end) {
//在存盤元素的陣列中查找，范圍是[start,end)，如果查找null物件，使用==比較，如果查找非null物件，那么呼叫Object.equals()方法判斷是否相等，找到則回傳下標，找不到回傳-1，
Object[] es = elementData;
if (o == null) {
for (int i = start; i < end; i++) {
if (es[i] == null) {
return i;
}
}
} else {
for (int i = start; i < end; i++) {
if (o.equals(es[i])) {
return i;
}
}
}
return -1;
}
public int lastIndexOf(Object o) {
//呼叫lastIndexOfRange()
return lastIndexOfRange(o, 0, size);
}
int lastIndexOfRange(Object o, int start, int end) {
//與indexOfRange()類似，但是是逆序查找，
Object[] es = elementData;
if (o == null) {
for (int i = end - 1; i >= start; i--) {
if (es[i] == null) {
return i;
}
}
} else {
for (int i = end - 1; i >= start; i--) {
if (o.equals(es[i])) {
return i;
}
}
}
return -1;
}
public Object clone() {
//呼叫父類的clone()方法，并且轉換為(ArrayList<?>)型別，新物件的陣列復制原來的陣列，并將新物件的修改次數設定為0，如果克隆失敗，拋出CloneNotSupportedException，E
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
public Object[] toArray() {
//回傳元素陣列的復制，
return Arrays.copyOf(elementData, size);
}
public <T> T[] toArray(T[] a) {
//泛型型別的陣列復制，如果傳入陣列的長度小于實際元素個數，那么回傳泛型陣列型別的，串列中元素陣列的復制，如果相等，直接復制，如果傳入陣列的長度大于實際元素個數，多余的位置用null填充，
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(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}E elementData(int index) {//以泛型型別回傳陣列中指定位置的元素 return (E) elementData[index];
}
@SuppressWarnings("unchecked")
static <E> E elementAt(Object[] es, int index) {
//以泛型型別返回給定陣列中指定位置的元素
return (E) es[index];
}
public E get(int index) {
//泛型方法get()首先呼叫Objects工具類中的checkIndex()方法，判斷index是否在陣列有效范圍內，該方法實際上是另一個定義相同的方法的呼叫，如果不在范圍內，拋出OutOfBoundsCheckIndex例外，否則回傳下標對應的元素，
Objects.checkIndex(index, size);
return elementData(index);
}
public E set(int index, E element) {
//泛型方法set()首先判斷是否越界，不越界就修改下標處元素的值，并回傳原來下標處的值，
Objects.checkIndex(index, size);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
private void add(E e, Object[] elementData, int s) {
//如果當前元素個數和長讀相等，那么自動擴容一個長度，放入元素并使size++，
if (s == elementData.length)
elementData = grow();
elementData[s] = e;
size = s + 1;
}
public boolean add(E e) {
//修改次數+1，呼叫add()多載方法，回傳true，
modCount++;
add(e, elementData, size);
return true;
}
public void add(int index, E element) {
//呼叫rangeCheckForAdd()
rangeCheckForAdd(index);
modCount++;
final int s;
Object[] elementData;
if ((s = size) == (elementData = https://www.cnblogs.com/Justhis610/p/this.elementData).length)
elementData = grow();
System.arraycopy(elementData, index,
elementData, index + 1,
s - index);
elementData[index] = element;
size = s + 1;
}
public E remove(int index) {
//首先判斷index是否合法，如果合法，定義一個final陣列等于當前元素陣列，然后保留泛型元素，呼叫fastRemove()，并將泛型元素回傳，
Objects.checkIndex(index, size);
final Object[] es = elementData;
@SuppressWarnings("unchecked") E oldValue =https://www.cnblogs.com/Justhis610/p/ (E) es[index];
fastRemove(es, index);
return oldValue;
}
public boolean equals(Object o) {
//如果是同一個物件，回傳true，如果不是List或其子類，回傳false，如果是，判斷物件的Clas是否是ArrayList，如果是就呼叫equalsArrayList()方法，否則呼叫equlsRange()方法
//最后呼叫checkForComodification()方法，
//在比較兩個List的程序中不能改變List的元素，否則會拋出并發修改例外，
if (o == this) {
return true;
}
if (!(o instanceof List)) {
return false;
}
final int expectedModCount = modCount;
// ArrayList can be subclassed and given arbitrary behavior, but we can
// still deal with the common case where o is ArrayList precisely
boolean equal = (o.getClass() == ArrayList.class)
? equalsArrayList((ArrayList<?>) o)
: equalsRange((List<?>) o, 0, size);
checkForComodification(expectedModCount);
return equal;
}
boolean equalsRange(List<?> other, int from, int to) {
//首先定義靜態變數指向當前元素陣列，如果范圍上界大于陣列長度，就拋出并發修改例外（ArrayList執行緒不同步），呼叫傳入List的迭代器，判斷每一個元素是否相等，元素個數是否相等，一致回傳true，否則回傳false，
final Object[] es = elementData;
if (to > es.length) {
throw new ConcurrentModificationException();
}
var oit = other.iterator();
for (; from < to; from++) {
if (!oit.hasNext() || !Objects.equals(es[from], oit.next())) {
return false;
}
}
return !oit.hasNext();
}
private boolean equalsArrayList(ArrayList<?> other) {
//如果是兩個ArrayList判斷，先判斷兩個al的元素個數是否相等，如果相等，靜態定義兩個陣列保存元素陣列，如果當前元素個數超過陣列長度，拋出并發修改例外，
//否則判斷每個元素是否相等，最后呼叫checkForComodification()方法，回傳判斷結果，
final int otherModCount = other.modCount;
final int s = size;
boolean equal;
if (equal = (s == other.size)) {
final Object[] otherEs = other.elementData;
final Object[] es = elementData;
if (s > es.length || s > otherEs.length) {
throw new ConcurrentModificationException();
}
for (int i = 0; i < s; i++) {
if (!Objects.equals(es[i], otherEs[i])) {
equal = false;
break;
}
}
}
other.checkForComodification(otherModCount);
return equal;
}
private void checkForComodification(final int expectedModCount) {
//判斷串列的修改次數是否相等，（主要用于多執行緒時）
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
public int hashCode() {
//呼叫hashCodeRange()方法，再判斷串列有沒有修改，如果修改拋出并發修改例外，回傳hash值，
int expectedModCount = modCount;
int hash = hashCodeRange(0, size);
checkForComodification(expectedModCount);
return hash;
}
int hashCodeRange(int from, int to) {
//如果元素個數大于陣列長度，拋出并發修改例外，定義hash初值為1，遍歷每個陣列元素，以31進制的方式回傳hash和（陣列元素為null時回傳0），回傳hash和就是lisr的hash值，
final Object[] es = elementData;
if (to > es.length) {
throw new ConcurrentModificationException();
}
int hashCode = 1;
for (int i = from; i < to; i++) {
Object e = es[i];
hashCode = 31 * hashCode + (e == null ? 0 : e.hashCode());
}
return hashCode;
}
public boolean remove(Object o) {
//定義一個標記found，如果找到一個相等的元素就終止這次回圈，但不重新進入回圈，即找到第一個相等的元素，呼叫fastRemove()，并回傳true，如果回圈沒有找到就回傳false，
//注意如果o是整型，ArrayList會呼叫洗掉指定下標方法，因為它是適合更小范圍的，
//迭代器遍歷時不能呼叫remove方法，會引起并發修改例外，
final Object[] es = elementData;
final int size = this.size;
int i = 0;
found: {
if (o == null) {
for (; i < size; i++)
if (es[i] == null)
break found;
} else {
for (; i < size; i++)
if (o.equals(es[i]))
break found;
}
return false;
}
fastRemove(es, i);
return true;
}
private void fastRemove(Object[] es, int i) {
//修改次數++，如果不是洗掉最后一個元素，就復制后面的元素到前面，將最后一個元素賦值為null，將size-1，
modCount++;
final int newSize;
if ((newSize = size - 1) > i)
System.arraycopy(es, i + 1, es, i, newSize - i);
es[size = newSize] = null;
}
public void clear() {
//修改次數++，將元素陣列全賦值為null，同時size賦值為0，
modCount++;
final Object[] es = elementData;
for (int to = size, i = size = 0; i < to; i++)
es[i] = null;
}
public boolean addAll(Collection<? extends E> c) {
//修改次數++，判斷c轉為陣列的長度是否為0，如果為0直接回傳false，如果陣列剩余長度不足集合元素個數，擴容至剛好足夠，將陣列復制到元素陣列匯總，修改size為當前個數，回傳true，
Object[] a = c.toArray();
modCount++;
int numNew = a.length;
if (numNew == 0)
return false;
Object[] elementData;
final int s;
if (numNew > (elementData = https://www.cnblogs.com/Justhis610/p/this.elementData).length - (s = size))
elementData = grow(s + numNew);
System.arraycopy(a, 0, elementData, s, numNew);
size = s + numNew;
return true;
}
public boolean addAll(int index, Collection<? extends E> c) {
//呼叫rangeCheckForAdd()，修改次數++，與addAll()多載方法類似，是從index處插入，
rangeCheckForAdd(index);
Object[] a = c.toArray();
modCount++;
int numNew = a.length;
if (numNew == 0)
return false;
Object[] elementData;
final int s;
if (numNew > (elementData = https://www.cnblogs.com/Justhis610/p/this.elementData).length - (s = size))
elementData = grow(s + numNew);
int numMoved = s - index;
if (numMoved > 0)
System.arraycopy(elementData, index,
elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size = s + numNew;
return true;
}
protected void removeRange(int fromIndex, int toIndex) {
//如果下界大于上界，拋出陣列下標越界例外，否則修改次數++，呼叫shiftTrailOverGap()方法，
if (fromIndex > toIndex) {
throw new IndexOutOfBoundsException(
outOfBoundsMsg(fromIndex, toIndex));
}
modCount++;
shiftTailOverGap(elementData, fromIndex, toIndex);
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/296189.html
標籤：其他
上一篇：12Java進階-IO與XML