【个人】系统学习-ArrayList

#ArrayList学习

学习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方法。