ArrayList源码阅读笔记

transient Object[] elementData;

private int size;

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

protected transient int modCount = 0;

ArrayList(int initialCapacity)

ArrayList()

ArrayList(Collection<? extends E> c)

void trimToSize();

void ensureCapacity(int minCapacity);

private void grow(int minCapacity);

public int size(); //返回size属性
public boolean isEmpty() ; //size是否为0
public boolean contains(Object o); //调用indexOf()是否大于等于0。
public int indexOf(Object o); //下面详解
public int lastIndexOf(Object o);//

public Object clone();

public Object[] toArray();
public <T> T[] toArray(T[] a);

public E get(int index);

public E set(int index, E element);

public boolean add(E e);
public void add(int index, E element);

public boolean addAll(Collection<? extends E> c);
public boolean addAll(int index, Collection<? extends E> c);

public E remove(int index);
public boolean remove(Object o);
protected void removeRange(int fromIndex, int toIndex);

public void clear();

public boolean removeAll(Collection<?> c); //batchRemove(c, false);
public boolean retainAll(Collection<?> c); //batchRemove(c, true);
/**
 * @param complement true时从数组保留指定集合中元素的值，为false时从数组删除指定集合中元素的值。
 * @return 数组中重复的元素都会被删除(而不是仅删除一次或几次)，有任何删除操作都会返回true
 */
private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            //遍历数组，并检查这个集合是否包含对应的值，移动要保留的值到数组前面，w最后值为要保留的元素的数量
            //简单点：若保留，就将相同元素移动到前段；若删除，就将不同元素移动到前段
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        }finally {
            //确保异常抛出前的部分可以完成期望的操作，而未被遍历的部分会被接到后面
            //r!=size表示可能出错了：c.contains(elementData[r])抛出异常
            if (r != size) {
                System.arraycopy(elementData, r,elementData, w,size - r);
                w += size - r;
            }
            //如果w==size：表示全部元素都保留了，所以也就没有删除操作发生，所以会返回false；反之，返回true，并更改数组
            //而w!=size的时候，即使try块抛出异常，也能正确处理异常抛出前的操作，因为w始终为要保留的前段部分的长度，数组也不会因此乱序
            if (w != size) {
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;//改变的次数
                size = w;   //新的大小为保留的元素的个数
                modified = true;
            }
        }
        return modified;
    }

private void writeObject(java.io.ObjectOutputStream s);
private void readObject(java.io.ObjectInputStream s);

public ListIterator<E> listIterator(int index); //new ListItr(index);开始位置为指定参数
public ListIterator<E> listIterator(); //return new ListItr(0);开始位置为0
public Iterator<E> iterator(); //return new Itr();

private class Itr implements Iterator<E> {}

int cursor;       //游标，下一个元素的索引，默认初始化为0
int lastRet = -1; //上次返回的元素的位置
int expectedModCount = modCount;//迭代过程不运行修改数组，否则就抛出异常

public boolean hasNext();
}

public E next();

public void remove();

public void forEachRemaining(Consumer<? super E> consumer);

final void checkForComodification();

private class ListItr extends Itr implements ListIterator<E> {}

ListItr(int index);

public boolean hasPrevious() {
    return cursor != 0; //根据游标判断是否有前一个元素
}
public int nextIndex() {
    return cursor; //游标即为下一个要迭代到的元素的下标
}
public int previousIndex() {
    return cursor - 1;//游标减一即上一个元素（当前已迭代的）的下标
}

public E previous();

public void set(E e);

public void add(E e);

//检查下标越界后，返回SubList的实例（用fromIndex、toIndex参数构造）作为子列表。
public List<E> subList(int fromIndex, int toIndex);

//用于subList()方法的下标越界检查方法
static void subListRangeCheck(int fromIndex, int toIndex, int size);

//SubList类
private class SubList extends AbstractList<E> implements RandomAccess
//注意在AbstractList.java源文件里也有一个SubList，然而并不是AbstractList的内部类，AbstractList.subList()方法会返回这个SubList的实例
class SubList<E> extends AbstractList<E> {}

private final AbstractList<E> parent; //保存母ArrayList的引用
private final int parentOffset; //subList方法的fromIndex参数
private final int offset;//subList方法的fromIndex参数
int size;//subList方法的参数相减：toIndex - fromIndex

public E set(int index, E e);
public E get(int index);
public int size();
public void add(int index, E e);
public E remove(int index);
protected void removeRange(int fromIndex, int toIndex);
public boolean addAll(Collection<? extends E> c) ;
public boolean addAll(int index, Collection<? extends E> c);
public Spliterator<E> spliterator();

public List<E> subList(int fromIndex, int toIndex);

public Iterator<E> iterator();
public ListIterator<E> listIterator(final int index);

private void rangeCheck(int index);
private void rangeCheckForAdd(int index);
private String outOfBoundsMsg(int index);
private void checkForComodification();

//forEach：for循环遍历elementData，每个元素分别调用action.accept(elementData[i])方法进行处理，如果处理过程中ArrayList被并行修改了，那么抛出ConcurrentModificationException异常
public void forEach(Consumer<? super E> action);

//spliterator：返回一个内部类 static final class ArrayListSpliterator<E> implements Spliterator<E>的实例。
//为了并行遍历数据源中的元素，Stream.isParallel()实现调用。下面专门一小节讲Spliterator接口
//这个实现类在private int getFence()方法里面初始化了fence = ArrayList的size，expectedModCount = ArrayList的modCount
public Spliterator<E> spliterator();

//删除指定条件的元素。先遍历数组，将符合条件（filter.test(element) == true）的元素的下标设置到一个BitSet的对应下标元素中，即这个BitSet哪一位为true，对应下标在ArrayList的元素就符合filter规则，并使用removeCount记录满足规则的个数。
//遍历后如果有满足filter规则的元素，则遍历数组，将被删除的元素后面的元素往前移，最后将末尾无效数据设为null。
//若有删除的元素则返回true，否则返回false
public boolean removeIf(Predicate<? super E> filter);

//与forEach()类似，检查operator不为空，然后遍历数组，每个元素调用operator.apply((E) elementData[i])进行处理，最后判断是否发生了并发修改，并增加modCount。
public void replaceAll(UnaryOperator<E> operator);

//调用Arrays.sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)进行排序，最后判断是否发生了并发修改，并增加modCount。
public void sort(Comparator<? super E> c);

boolean tryAdvance(Consumer<? super T> action);
Spliterator<T> trySplit();
long estimateSize();
int characteristics();