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)
 ​