学习ArrayList源码

构造方法

//初始容量
private static final int DEFAULT_CAPACITY = 10;
//空数组
private static final Object[] EMPTY_ELEMENTDATA = new Object[0];
//瞬时态 数组
private transient Object[] elementData;
//有参构造  var1位长度
public ArrayList(int var1) {
    if (var1 < 0) {
        throw new IllegalArgumentException("Illegal Capacity: " + var1);
    } else {
        this.elementData = new Object[var1];
    }
}
//无参构造  默认长度为10
public ArrayList() {
    this.elementData = EMPTY_ELEMENTDATA;
}
// 传入集合，将集合转换成数组，将数组赋值给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);
    }
}

添加元素方法

//添加方法，内部也是判断数组是否超容，如果没有，则将值放入数组，超容的话，增大数组容量再赋值
public boolean add(E var1) {
    this.ensureCapacityInternal(this.size + 1);
    this.elementData[this.size++] = var1;
    return true;
}
//判断是否超容
private void ensureCapacityInternal(int var1) {
//判断数组是否与初始容量有变化
    if (this.elementData == EMPTY_ELEMENTDATA) {
    //数组长度+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) {
//现有数组容量
    int var2 = this.elementData.length;
    //现有数组容量增加1/2
    int var3 = var2 + (var2 >> 1);
    //判断是否够用
    if (var3 - var1 < 0) {
    //不够用直接将Var1的值赋值给Var3
        var3 = var1;
    }
//判断是否超初最大容量
    if (var3 - 2147483639 > 0) {
        var3 = hugeCapacity(var1);
    }
//新数组
    this.elementData = Arrays.copyOf(this.elementData, var3);
}

ArrayList实现了clone接口，并重写了clone方法

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

//克隆方法  --浅克隆，以后总结深克隆和浅克隆的区别
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实现了Serializable接口，并有序列化和反序列化的方法，开始还没明白elementData变量加Tran'sient的用处，因为加了Transient后，序列化的时候，是不会操作这个成员的，后来查了资料，发现，假如elementData的长度为10，而其中只有5个元素，那么在序列化的时候只需要存储5个元素，而数组中后面5个元素是不需要存储的。于是将elementData定义为transient，避免了Java自带的序列化机制，并定义了两个方法，实现了自己可控制的序列化操作。

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();
        }
    }
}

总结

ArrayList是一个初始化容量为10（也可通过传入长度控制初始化容量）的底层为数组的集合，自动扩容为原容量的1.5倍，有add、remove、addAll、writeObject等方法，并可使用clone方法。