学习笔记---ArrayList源码解析

当arrylist 初始化时，会给一个空值。 

先判断是否超出数组长度，超出创建新数组

        ArrayList arrayList=new ArrayList();
        System.out.println("arrayList:"+arrayList.size());
       

   

 

输出结果为0

当arrylist调用add方法 

boolean add = arrayList.add("1");
        System.out.println("arrayList:"+arrayList.size());

进入add源码看

public boolean add(E e) {
        进入到ensureCapacityInternal中，判断是否为第一次使用，给数组初始化长度
        size在类中int初始化为0；
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        赋值
        elementData[size++] = e;
        return true;
    }

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; 
private static final int DEFAULT_CAPACITY = 10;

private void ensureCapacityInternal(int minCapacity) {
           如果elementData现有的数据数组长度=空的话
           把10赋值给minCapacity
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
           ensureExplicitCapacity判断是否达到上限
        ensureExplicitCapacity(minCapacity);
    }

private void ensureExplicitCapacity(int minCapacity) {
//父类的count
        modCount++;

        // overflow-conscious code
      minCapacity是想要的长度，element 是现有的长度
        if (minCapacity - elementData.length > 0)
             增长
            grow(minCapacity);
    }

   

private void grow(int minCapacity) {
        // overflow-conscious code
         //获取现有数据的数组长度
        int oldCapacity = elementData.length; 
         把现有的数据长度*1.5倍
            >>表示二进制中右移一位比直接/2更快
        int newCapacity = oldCapacity + (oldCapacity >> 1);
            新的数据长度小于min的话就用min的
        if (newCapacity - minCapacity < 0)
            newCapacity = 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);
           现在elementData的长度为10
    }

  

 public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

最后一直回到给elemetn赋值；

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        赋值
        elementData[size++] = e;
        return true;
    }

size=1;

a=size++；

b=size;

结果a=1,b=2;

elementData[1]=e；size变成2；

----------------------------arraylist无参初始化结束---------------------------------------

 当 size=1时 minCapacity=2;

elementData在初始化的时候被创建了长度为10的数组；

2-10进入不了grow

private void ensureExplicitCapacity(int minCapacity) {
//父类的count
        modCount++;

        // overflow-conscious code
      minCapacity是想要的长度，element 是现有的长度
        if (minCapacity - elementData.length > 0)
             增长
            grow(minCapacity);
    }

 回到这里来赋值

public boolean add(E e) {
        进入到ensureCapacityInternal中，判断是否为第一次使用，给数组初始化长度
        size在类中int初始化为0；
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        赋值
        elementData[size++] = e;
        return true;
    }

----------------------------arraylist不超出element现有长度执行完成---------------------------------------

 

 当 size=10时 minCapacity=11;

elementData在初始化的时候被创建了长度为10的数组；

11-10进入grow

private void ensureExplicitCapacity(int minCapacity) {
//父类的count
        modCount++;

        // overflow-conscious code
      minCapacity是想要的长度，element 是现有的长度
        if (minCapacity - elementData.length > 0)
             增长
            grow(minCapacity);
    }

把10*1.5倍并创建新的数组 

private void grow(int minCapacity) {
        // overflow-conscious code
         //获取现有数据的数组长度
        int oldCapacity = elementData.length; 
         把现有的数据长度*1.5倍
            >>表示二进制中右移一位比直接/2更快
        int newCapacity = oldCapacity + (oldCapacity >> 1);
            新的数据长度小于min的话就用min的
        if (newCapacity - minCapacity < 0)
            newCapacity = 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);
          现在elementData长度15
    }

最后在进行赋值

----------------------------arraylist超出element现有长度执行完成---------------------------------------