容器List源码解析

List是个接口，继承自Collection

容器 迭代器 Collection

public interface List<E> extends Collection<E> {
    //List的尺寸大小
    int size();
    
    //判断List是否为空
    boolean isEmpty();
    
    //判断List是否包含指定元素
    boolean contains(Object o);

    //迭代器
    Iterator<E> iterator();
    
    //将容器转化为数组
    Object[] toArray();

    //将容器转化为指定类型的数组
    <T> T[] toArray(T[] a);

    //添加指定元素到List
    boolean add(E e);

    //移除指定元素
    boolean remove(Object o);

    //判断当前容器是否包含指定容器中的所有元素
    boolean containsAll(Collection<?> c);

    //添加指定容器中的所有元素到当前容器中
    boolean addAll(Collection<? extends E> c);

    //添加指定容器中的所有元素到当前容器中，同时指定了添加的索引位置
    boolean addAll(int index, Collection<? extends E> c);

    //从当前容器中移除指定容器中的所有元素
    boolean removeAll(Collection<?> c);

    //取交集，并将交集赋值给当前容器
    boolean retainAll(Collection<?> c);

    //
    default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }

    //
    @SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

    //清理当前容器
    void clear();

    //比较
    boolean equals(Object o);

    //hashCode
    int hashCode();

    //从容器中按照索引取出一个元素
    E get(int index);

    //指定索引，将指定元素替换到到容器中索引所在位置
    E set(int index, E element);

    //指定索引，将指定元素加入到当前容器中
    void add(int index, E element);

    //指定索引，移除索引对应的元素
    E remove(int index);

    //获取指定元素在当前容器中的索引位置
    int indexOf(Object o);

    //获取指定元素在当前容器中最后一次出现的索引位置
    int lastIndexOf(Object o);

    //迭代器
    ListIterator<E> listIterator();

    //迭代器
    ListIterator<E> listIterator(int index);

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

    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }
}

public interface ListIterator<E> extends Iterator<E> {
    //判断是否有下一个
    boolean hasNext();

    //下一个
    E next();

    //判断是否有上一个
    boolean hasPrevious();
    
    //上一个
    E previous();

    //下一个的索引
    int nextIndex();

    //上一个的索引
    int previousIndex();
    
    //移除
    void remove();

    //替换
    void set(E e);

   //添加
    void add(E e);
}

这两个都是接口，接口就是用来制定规范的，接下来看实现

可以看到，List的子类还是蛮多的，这里我们主要关注这几个
Vector
Stack
AbstractList
LinkedList
ArrayList
CopyOnWriteArrayList

先从我们所熟知的ArrayList，但是ArrayList是继承自AbstractList的，所以，就先说一下AbstractList

提前说一下，这个不太好硬解释，毕竟还是结合使用起来比较好解释理解，硬巴巴的解释有点枯涩

容器 AbstractList 源码解析

---