数据结构之List

直接上JDK源码

List<E>源代码

public interface List extends Collection {    int size();    boolean isEmpty();    boolean contains(Object o);    Iterator iterator();    Object[] toArray();     T[] toArray(T[] a);    boolean add(E e);    boolean remove(Object o);    boolean containsAll(Collection c);    boolean addAll(Collection c);    boolean addAll(int index, Collection c);    boolean removeAll(Collection c);    boolean retainAll(Collection c);    default void replaceAll(UnaryOperator operator) {        Objects.requireNonNull(operator);        final ListIterator li = this.listIterator();        while (li.hasNext()) {            li.set(operator.apply(li.next()));        }    }    default void sort(Comparator c) {        Collections.sort(this, c);    }    void clear();    boolean equals(Object o);    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 listIterator();    ListIterator listIterator(int index);    List subList(int fromIndex, int toIndex);    @Override    default Spliterator spliterator() {        return Spliterators.spliterator(this, Spliterator.ORDERED);    }}

Collection<E>源代码

public interface Collection extends Iterable {    int size();    boolean isEmpty();    boolean contains(Object o);    Iterator iterator();    Object[] toArray();     T[] toArray(T[] a);    boolean add(E e);    boolean remove(Object o);    boolean containsAll(Collection c);    boolean addAll(Collection c);    boolean removeAll(Collection c);    default boolean removeIf(Predicate filter) {        Objects.requireNonNull(filter);        boolean removed = false;        final Iterator each = iterator();        while (each.hasNext()) {            if (filter.test(each.next())) {                each.remove();                removed = true;            }        }        return removed;    }    boolean retainAll(Collection c);    void clear();    boolean equals(Object o);    int hashCode();    @Override    default Spliterator spliterator() {        return Spliterators.spliterator(this, 0);    }    default Stream stream() {        return StreamSupport.stream(spliterator(), false);    }    default Stream parallelStream() {        return StreamSupport.stream(spliterator(), true);    }}

Iterable<E>源代码

public interface Iterable {    Iterator iterator();    default void forEach(Consumer action) {        Objects.requireNonNull(action);        for (T t : this) {            action.accept(t);        }    }    default Spliterator spliterator() {        return Spliterators.spliteratorUnknownSize(iterator(), 0);    }}

List的实现类：

AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList,RoleUnresolvedList, Stack, Vector
这里只说常用的ArrayList、LinkedList、Stack、Vector

java.util.ArrayList< E >

ArrayList有点类似于数组，相比较于数组而言，ArrayList可以动态的更改元素个数，相对于数组较为灵活。 
每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。 
在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。

new ArrayList(); 构造一个初始容量为 10 的空列表

java.util.Vector< E >

Vector和ArrayList的区别在于Vector是线程同步的。 
Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。 
每个向量会试图通过维护 capacity 和 capacityIncrement 来优化存储管理。capacity 始终至少应与向量的大小相等；这个值通常比后者大些，因为随着将组件添加到向量中，其存储将按capacityIncrement 的大小增加存储块。应用程序可以在插入大量组件前增加向量的容量；这样就减少了增加的重分配的量。

java.util.LinkedList< E >

与上面介绍的类一样，LinkedList也实现了List接口，在其内部以链表的方式维护元素，LinkedList具备List接口的所有方法，另外，LinkedList类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。

java.util.Stack< E >

Stack类继承自Vector，所以Stack和Vector一样也是线程安全的。Stack 类表示后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展 ，允许将向量视为堆栈。它提供了通常的 push 和 pop 操作，以及取堆栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search 方法。

其他不常用的可以自己下JDK源码看看