ArrayList源码浅析-CSDN博客

本文链接：https://blog.csdn.net/weixin_44932054/article/details/100102753

ArrayList

源码浅析

ArrayList实现了List接口，继承了AbstractList，底层是数组实现的，一般我们把它认为是可以自增扩容的数组。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{

从上面源码中可以看到首先它继承了AbstractList类，实现了List，RandomAccess，Cloneable，java.io.Serializable接口

从中可以总结出ArrayList的特点：
1. ArrayList实现了List接口。所以其中元素可以重复，且可以为null。
2. ArrayList实现了RandomAccess接口( 只是个标注接口，并没有实际的方法）。支持快速随机访问，这里主要表现为可以通过下标直接访问(底层是数组实现的，所以直接用数组下标来索引)。
3. ArrayList实现了Cloneable接口。所以可以被克隆。
4. ArrayList实现了Serializable接口。因此它支持序列化，能够通过序列化传输(实际上java类库中的大部分类都是实现了这个接口的)。

ArrayList源码分析
1.属性分析：

  private static final long serialVersionUID = 8683452581122892189L;
    /**
     * 序列化id
     */
     
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 默认初始容量为10
     */
     
    private static final Object[] EMPTY_ELEMENTDATA = {};
    /**
     * 空数组对象，如果采用默认构造方式，初始化为空数组
     * 第一个元素已经添加
     */
     
    transient Object[] elementData; 
    /**
     * 用于保存数据的数组
     *
     * @serial
     */
     
    private int size;
    /**
     * 当前容量
     */

2.构造函数

//带初始容量的构造函数
public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }


//默认构造函数（无参构造方法）
    public ArrayList() {
      //将数组初始化为空数组
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
       }


//带参数的构造方法（这个方法是直接将一个集合作为ArrayList的元素此时elementData即为集合c转为的数组，size即为elementData的长度。这里size是ArrayList的一个int型私有变量，用于记录该list集合中当前元素的数量，注意不是容量）
      public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

3.方法分析

增加（add）

//插入一个元素到线性表的末尾
 public boolean add(E e) {
       //调用ensureCapacityInternal()方法
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //将元素e赋值给elementData[size]
        //然后size++
        elementData[size++] = e;
        return true;
    }

//指定位置index插入元素e
  public void add(int index, E element) {
      //调用rangeCheckForAdd()方法检查范围
        rangeCheckForAdd(index);
      //同样调用ensureCapacityInternal()方法
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //将原数组index之后的值包括index都向后移动一个位置
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        //将元素e插入index位置
        elementData[index] = element;
        //容量size++
        size++;
    }


    /*
 *检验下标是否正确
 */
private void rangeCheckForAdd(int index) {
	//下标不正确抛出异常
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

/*
 *判断容量的大小
 */
private void ensureCapacityInternal(int minCapacity) {
	//判断当前容量是否是默认的空容量
   if (elementData == EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
   //调用ensureExplicitCapability方法判断插入后的容量和数组长度的大小
    ensureExplicitCapacity(minCapacity); 
}

/**
 *判断插入后的容量和数组长度的大小
 */
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    //如果当前插入后的容量比数组长度大，调用grow方法进行扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);  
}

/*
 *扩容
 */
private void grow(int minCapacity) {
	//保存老的数组容量
    int oldCapacity = elementData.length;
    //新的数组容量 1.5倍扩容
    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);
}
private static int hugeCapacity(int minCapacity) {
	//异常处理
    if (minCapacity < 0)
        throw new OutOfMemoryError();
    //如果数组容量超过最大数组容量，返回整型的最大值，否则返回最大数组容量
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

删除（remove）

//删除线性表的指定位置的一个元素
public E remove(int index) {
      //范围检查
        rangeCheck(index);
        modCount++;
      //保存删除的元素
        E oldValue = elementData(index);
      //要移动的第一个元素的下标
        int numMoved = size - index - 1;
      //如果删除的不是最后一个元素，那么如果numMoved大于0，将index以后的元素全部向前移动一个位置
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
      //将最后一个位置置为null，且GC自动回收
        elementData[--size] = null; // clear to let GC do its work
      //返回删除的元素
        return oldValue;
    }


 *
 *范围检测
 */
private void rangeCheck(int index) {
	//如果index比数组容量大，抛出异常
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}


/*
 *删除所有和o相等的第一个元素
 */
public boolean remove(Object o) {
	//空指针检验
	if (o == null) {
	     for (int index = 0; index < size; index++)
	     //判断数组中有没有null
	          if (elementData[index] == null) {
	              fastRemove(index);
	              return true;
	          }
	} else {
	    for (int index = 0; index < size; index++)
	    //判断是否相等
	        if (o.equals(elementData[index])) {
	        //调用fastRemove方法删除index位置元素
	            fastRemove(index);
	            return true;
	        }
	}
	//没有这个元素，返回false
	return false;
}

/*
 1. 删除最后一个元素，与remove的后半部分完全相同
 */
private void fastRemove(int index) {
    modCount++;
    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
}

修改（set）

  public E set(int index, E element) {
      //范围检查，同上
        rangeCheck(index);
      //oldValue保存原来的元素
        E oldValue = elementData(index);
      //将index下标处的值修改为element
        elementData[index] = element;
      //返回旧元素
        return oldValue;
    }

查找（get）

 public E get(int index) {
      //范围检查
        rangeCheck(index);
      //返回index下标处的元素
        return elementData(index);
    }