ArrayList源码解析

单列集合

这是集合的一个继承关系

单列集合主要有三个接口，List；Queue；Set，他们的实现类分别是在它们的实现类中，我们要做的就是剖析它的源码：

ArrayList源码解析

1. 看看共性，就是公共的集合有哪些方法

// 判断集合的长度
int size();
//判断集合是否为空
boolean isEmpty();
//集合是否包含这个元素
boolean contains(Object o);
//底层调用了indexOf(o)的方法，就是意思是，返回o的索引
public boolean contains(Object o) {
    return indexOf(o) >= 0;
}
//把所有的object[]都置空
void clear()
//迭代器
Iterator<E> iterator();
//类型装换为 Object 数组
Object[] toArray();
//类型装换为指定类型的数组
<T> T[] toArray(T[] a);
//可以触发扩容机制
boolean add(E e);
//底层调用的是fastRemove(index);这个方法
boolean remove(Object o);
//包含所有
boolean containsAll(Collection<?> c);
//添加所有
boolean addAll(Collection<? extends E> c);
//移除所有
boolean removeAll(Collection<?> c);

//再去看一看indexOf(o)源码
public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
        //为空也会判断，应该是判断最后一个索引，就是索引
    } else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

//clear 的源码
public void clear() {
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}
//add的源码
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
//remove 的源码
public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}
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
}

最关键的地方来了，来探究一下ArrayList的扩容机制

首先要知道ArrayList这几个属性

/**

默认的初始容量

* Default initial capacity.
*/
private static final int DEFAULT_CAPACITY = 10;

/**

空的实例

* Shared empty array instance used for empty instances.
*/
private static final Object[] EMPTY_ELEMENTDATA = {};

ArrayList的底层实现原理,用来放ArrayList集合

transient Object[] elementData; // non-private to simplify nested class access

//存放的Object数组的长度

private int size;

如果你使用的是无参构造器的话

//它会默认赋值为空
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//然后调用add()方法去添加集合，会触发扩容机制 ensureCapacityInternal
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
//扩容机制会去调用ensureCapacityInternal，还会判断默认容量使用这个方法calculateCapacity
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //第一次扩容的话，就会使用这个这个比较，如果使用了DEFAULT_CAPACITY，grow方法
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}
//扩容机制会去调用ensureExplicitCapacity
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
/*
modCount++;记录的是ArayList的修改的总次数，目前，用来检查列表中的元素是否发生结构性变化
（列表元素数量发生改变）了，主要在多线程环境下需要使用，防止一个线程正在迭代遍历，
另一个线程修改了这个列表的结构。这是网上的说法，我具体也不是很清楚
*/

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    //就是传过来的容量大于，当前的容量时，触发grow
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

这个是扩容的核心代码了，所以把它提出来单独说明

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    //扩容到以前的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        //扩容后，还是比传过来的容量小，直接把传过来的容量赋给当前容量
        newCapacity = minCapacity;
    //判断是否大于最大的容量，大于执行hugeCapacity方法
    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) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
    MAX_ARRAY_SIZE;
}

这行代码是添加一个集合的

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    //    elementData = Arrays.copyOf(elementData, newCapacity);
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

这是给了一个初始容量

//给了一个初始容量的话，就直接把给定的容量赋值给Object[]数组
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);
    }
}


  } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
    }
}