List总结

List接口

public interface List<E> extends Collection<E>

继承了Collection接口中的所有方法，并且有自己的新增方法：

//继承于Collection接口的方法
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean removeAll(Collection<?> c);
default boolean removeIf(Predicate<? super E> filter);
boolean retainAll(Collection<?> c);
void clear();
boolean equals(Object o);
int hashCode();

//新增方法
boolean addAll(int index, Collection<? extends E> c);
default void replaceAll(UnaryOperator<E> operator);
default void sort(Comparator<? super E> c);
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);

可见List的元素都有自己的索引，是有序集合
其中listIterator()方法返回的是ListIterator迭代器，与iterator()方法返回的Iterator迭代器有所不同
Iterator接口：

public interface Iterator<E>

boolean hasNext();
E next();
default void forEachRemaining(Consumer<? super E> action)；

ListIterator接口：

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);

可见ListIterator接口增加了索引以及向前遍历的概念

List类

抽象类AbstractList继承了AbstractCollection类
抽象类AbstractSequentialList继承了AbstractList类
集合类ArrayList继承了AbstractList类
集合类LinkedList继承了AbstractSequentialList类
它们也都实现了List接口

ArrayList源码分析

声明：

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

transient Object[] elementData;

此为底层数据元素，可见ArrayList基于数组
看其构造方法：

public ArrayList(int initialCapacity);
public ArrayList();
public ArrayList(Collection<? extends E> c);

看其他方法：

public void trimToSize();
public void ensureCapacity(int minCapacity);
public int size();
public boolean isEmpty();
public boolean contains(Object o);
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 E remove(int index);
public boolean remove(Object o);
public void clear();
public boolean addAll(Collection<? extends E> c);
public boolean addAll(int index, Collection<? extends E> c);
public boolean removeAll(Collection<?> c);
public boolean retainAll(Collection<?> c);
public ListIterator<E> listIterator(int index);
public ListIterator<E> listIterator();
public Iterator<E> iterator();

    //Iterator迭代器方法
    public boolean hasNext();
    public E next();
    public void remove();
    public void forEachRemaining(Consumer<? super E> consumer);

    //ListIterator迭代器方法
    //继承自Iterator迭代器的方法
    public boolean hasNext();
    public E next();
    public void remove();
    public void forEachRemaining(Consumer<? super E> consumer);
    public boolean hasPrevious();
    //新增方法
    public int nextIndex();
    public int previousIndex();
    public E previous();
    public void set(E e);
    public void add(E e);

public List<E> subList(int fromIndex, int toIndex);
public Spliterator<E> spliterator();
public void forEach(Consumer<? super E> action);
public boolean removeIf(Predicate<? super E> filter);
public void replaceAll(UnaryOperator<E> operator);
public void sort(Comparator<? super E> c);

综上可知，ArrayList是有序集合，可动态改变，底层完全基于数组实现，随机存取效率较高

LinkedList源码分析

声明

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable

其实现了Deque接口，所以也会有一些队列方法

transient Node<E> first;
transient Node<E> last;
private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
}

可见其底层基于链表实现
看构造方法：

public LinkedList();
public LinkedList(Collection<? extends E> c);

看其他方法：

public E getFirst();
public E getLast();
public E removeFirst();
public E removeLast();
public void addFirst(E e);
public void addLast(E e);
public boolean contains(Object o);
public int size();
public boolean add(E e);
public boolean remove(Object o);
public boolean addAll(Collection<? extends E> c);
public boolean addAll(int index, Collection<? extends E> c);
public void clear();
public E get(int index);
public E set(int index, E element);
public void add(int index, E element);
public E remove(int index);
public int indexOf(Object o);
public int lastIndexOf(Object o);

//队列方法（链表头为队头）
public E peek();//队列为空则返回null
public E element();//队列为空则抛异常
public E poll();//队列为空则返回null
public E remove();//队列为空则抛异常
public boolean offer(E e);//队尾入队

//双端队列方法
public boolean offerFirst(E e);
public boolean offerLast(E e);
public E peekFirst();
public E peekLast();
public E pollFirst();
public E pollLast();

//栈方法（链表头为栈顶）
public void push(E e);
public E pop();

public boolean removeFirstOccurrence(Object o);
public boolean removeLastOccurrence(Object o);
public ListIterator<E> listIterator(int index);
public Iterator<E> descendingIterator();
public Object clone();
public Object[] toArray();
public <T> T[] toArray(T[] a);
public Spliterator<E> spliterator();

综上可知，LinkedList是有序集合，可动态改变，底层基于链表实现，插入删除效率较高，并且可以用来表示队列、双端队列、栈这些数据结构