學(xué)習(xí)ArrayList源碼

構(gòu)造方法

//初始容量
private static final int DEFAULT_CAPACITY = 10;
//空數(shù)組
private static final Object[] EMPTY_ELEMENTDATA = new Object[0];
//瞬時(shí)態(tài) 數(shù)組
private transient Object[] elementData;
//有參構(gòu)造  var1位長度
public ArrayList(int var1) {
    if (var1 < 0) {
        throw new IllegalArgumentException("Illegal Capacity: " + var1);
    } else {
        this.elementData = new Object[var1];
    }
}
//無參構(gòu)造  默認(rèn)長度為10
public ArrayList() {
    this.elementData = EMPTY_ELEMENTDATA;
}
// 傳入集合，將集合轉(zhuǎn)換成數(shù)組，將數(shù)組賦值給elementData
public ArrayList(Collection<? extends E> var1) {
    this.elementData = var1.toArray();
    this.size = this.elementData.length;
    if (this.elementData.getClass() != Object[].class) {
        this.elementData = Arrays.copyOf(this.elementData, this.size, Object[].class);
    }
}

添加元素方法

//添加方法，內(nèi)部也是判斷數(shù)組是否超容，如果沒有，則將值放入數(shù)組，超容的話，增大數(shù)組容量再賦值
public boolean add(E var1) {
    this.ensureCapacityInternal(this.size + 1);
    this.elementData[this.size++] = var1;
    return true;
}
//判斷是否超容
private void ensureCapacityInternal(int var1) {
//判斷數(shù)組是否與初始容量有變化
    if (this.elementData == EMPTY_ELEMENTDATA) {
    //數(shù)組長度+1和初始容量最大值
        var1 = Math.max(10, var1);
    }
    //判斷容量是否超
    this.ensureExplicitCapacity(var1);
}
private void ensureExplicitCapacity(int var1) {
    ++this.modCount;
    if (var1 - this.elementData.length > 0) {
    //容量增加
        this.grow(var1);
    }
}
private void grow(int var1) {
//現(xiàn)有數(shù)組容量
    int var2 = this.elementData.length;
    //現(xiàn)有數(shù)組容量增加1/2
    int var3 = var2 + (var2 >> 1);
    //判斷是否夠用
    if (var3 - var1 < 0) {
    //不夠用直接將Var1的值賦值給Var3
        var3 = var1;
    }
//判斷是否超初最大容量
    if (var3 - 2147483639 > 0) {
        var3 = hugeCapacity(var1);
    }
//新數(shù)組
    this.elementData = Arrays.copyOf(this.elementData, var3);
}

ArrayList實(shí)現(xiàn)了clone接口，并重寫了clone方法

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable

//克隆方法  --淺克隆，以后總結(jié)深克隆和淺克隆的區(qū)別
public Object clone() {
    try {
        ArrayList var1 = (ArrayList)super.clone();
        var1.elementData = Arrays.copyOf(this.elementData, this.size);
        var1.modCount = 0;
        return var1;
    } catch (CloneNotSupportedException var2) {
        throw new InternalError();
    }
}

序列化方法

ArrayList實(shí)現(xiàn)了Serializable接口，并有序列化和反序列化的方法，開始還沒明白elementData變量加Tran'sient的用處，因?yàn)榧恿?strong>Transient后，序列化的時(shí)候，是不會操作這個(gè)成員的，后來查了資料，發(fā)現(xiàn)，假如elementData的長度為10，而其中只有5個(gè)元素，那么在序列化的時(shí)候只需要存儲5個(gè)元素，而數(shù)組中后面5個(gè)元素是不需要存儲的。于是將elementData定義為transient，避免了Java自帶的序列化機(jī)制，并定義了兩個(gè)方法，實(shí)現(xiàn)了自己可控制的序列化操作。

private void writeObject(ObjectOutputStream var1) throws IOException {
    int var2 = this.modCount;
    var1.defaultWriteObject();
    var1.writeInt(this.size);
    for(int var3 = 0; var3 < this.size; ++var3) {
        var1.writeObject(this.elementData[var3]);
    }
    if (this.modCount != var2) {
        throw new ConcurrentModificationException();
    }
}
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
    this.elementData = EMPTY_ELEMENTDATA;
    var1.defaultReadObject();
    var1.readInt();
    if (this.size > 0) {
        this.ensureCapacityInternal(this.size);
        Object[] var2 = this.elementData;
        for(int var3 = 0; var3 < this.size; ++var3) {
            var2[var3] = var1.readObject();
        }
    }
}

總結(jié)

ArrayList是一個(gè)初始化容量為10（也可通過傳入長度控制初始化容量）的底層為數(shù)組的集合，自動擴(kuò)容為原容量的1.5倍，有add、remove、addAll、writeObject等方法，并可使用clone方法。