arraylist源码解析

arraylist的源码剖析

 
 arraylist不适合频繁扩容。
 arraylist不适合在数组中间插入元素，每次插入都会剩下的位置往后挪一位。
 适合随机查询。
 默认初始化大小10.object数组默认

add方法

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

第二行 ensureCapacityInternal(size + 1);

每次往arraylist中塞如数据的时候，人家都会判断一下，当前数组的元素是否塞满了，如果塞满了的话，此时会扩容这个数组，将老数组元素拷贝到新数组中去。

第三行 elementData[size++] = e; 把数组的结果赋值给当前传入的元素

set方法的源码

   public E set(int index, E element) {
         rangeCheck(index);
 
         E oldValue = elementData(index);
         elementData[index] = element;
         return oldValue;
     }

第二行，rangeCheck检查索引长度是否越界，抛出数组越界异常

第四行拿到当前索引的值

第五行将传入的值覆盖当前index，

6返回老值。

remove

    public E remove(int index) {
         rangeCheck(index);
 
         modCount++;
         E oldValue = elementData(index);
 
         int numMoved = size - index - 1;
         if (numMoved > 0)
             System.arraycopy(elementData, index+1, elementData, index,
                              numMoved);
         elementData[--size] = null; // clear to let GC do its work
 
         return oldValue;
     }

检查是否越界

5拿到老的值

numMoved是index后面还有几个元素

9数组拷贝

11最后一位null处理，

返回老值。

get

     public E get(int index) {
         rangeCheck(index);
 
         return elementData(index);
     }

检查index后返回数组中的数据。

数组扩容操作和元素拷贝

假设我们现在用的默认的数组大小是10，现在已经往这个数组添加了10个元素，size=10，capacity=10，调用add方法插入元素，就进行扩容

数组扩容，原来的长度+长度/2 （原数组的1.5倍），调用elementData = Arrays.copyOf(elementData, newCapacity);

    private void ensureCapacityInternal(int minCapacity) {
         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
             minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
         }
 
         ensureExplicitCapacity(minCapacity);
     }

调用的方法ensureExplicitCapacity

     private void ensureExplicitCapacity(int minCapacity) {
         modCount++;
 
         // overflow-conscious code
         if (minCapacity - elementData.length > 0)
             grow(minCapacity);
     }

第五行当前传入数据的个数已经大于现在数组的总长度了

调用的方法grow

 private void grow(int minCapacity) {
         // overflow-conscious code
         int oldCapacity = elementData.length;
         int newCapacity = oldCapacity + (oldCapacity >> 1);
         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);
     }

 int newCapacity = oldCapacity + (oldCapacity >> 1);
 新的数组长度=老+老>>1      15=10+(10/2)