Java中的List是一个接口，它定义了一组操作列表的方法。List接口的常见子类包括ArrayList、LinkedList和Vector等。
以下是Java中List接口及其常见方法的源码解析：
1. List接口定义
```
public interface List<E> extends Collection<E> {
// 返回列表中元素的数量
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);
// 仅保留列表中与指定集合中元素相同的元素
boolean retainAll(Collection<?> c);
// 清空列表中所有元素
void clear();
// 获取列表中指定位置的元素
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);
// 返回一个列表的子列表
List<E> subList(int fromIndex, int toIndex);
// 返回一个列表的并行流
Stream<E> parallelStream();
}
```
2. ArrayList类
ArrayList是一个基于数组实现的List类，它提供了调整大小、遍历和随机访问等常见操作。以下是ArrayList的常见方法：
```
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
// 构造函数
public ArrayList(int initialCapacity);
public ArrayList();
public ArrayList(Collection<? extends E> c);
// 返回列表中元素的数量
public int size();
// 判断列表是否为空
public boolean isEmpty();
// 判断列表中是否包含指定元素
public boolean contains(Object o);
// 返回列表中所有元素的迭代器
public Iterator<E> iterator();
// 返回列表中所有元素的数组
public Object[] toArray();
// 将列表中所有元素拷贝到指定数组中
public <T> T[] toArray(T[] a);
// 添加指定元素到列表末尾
public boolean add(E e);
// 删除列表中指定元素
public boolean remove(Object o);
// 判断列表中是否包含指定集合中的所有元素
public boolean containsAll(Collection<?> c);
// 向列表中添加指定集合中的所有元素
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 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 List<E> subList(int fromIndex, int toIndex);
// 返回一个列表的并行流
public Stream<E> parallelStream();
// 对列表进行排序
public void sort(Comparator<? super E> c);
}
```
3. LinkedList类
LinkedList是一个基于双向链表实现的List类，它提供了添加、删除、检索以及与栈和队列相关的方法。以下是LinkedList的常见方法：
```
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
// 构造函数
public LinkedList();
public LinkedList(Collection<? extends E> c);
// 返回列表中元素的数量
public int size();
// 判断列表是否为空
public boolean isEmpty();
// 判断列表中是否包含指定元素
public boolean contains(Object o);
// 返回列表中所有元素的迭代器
public Iterator<E> iterator();
// 返回列表中所有元素的反向迭代器
public Iterator<E> descendingIterator();
// 在列表末尾添加指定元素
public boolean add(E e);
// 在列表头部添加指定元素
public void addFirst(E e);
// 在列表末尾添加指定元素
public void addLast(E e);
// 删除列表中指定元素
public boolean remove(Object o);
// 删除并返回列表头部的元素
public E remove();
// 删除并返回列表头部的元素
public E removeFirst();
// 删除并返回列表末尾的元素
public E removeLast();
// 获取列表头部元素
public E getFirst();
// 获取列表末尾元素
public E getLast();
// 替换列表中指定位置的元素
public E set(int index, E element);
// 在列表中指定位置插入指定元素
public void add(int index, E element);
// 获取列表中指定位置的元素
public E get(int index);
// 删除列表中指定位置的元素
public E remove(int index);
// 获取列表中指定元素第一次出现的位置
public int indexOf(Object o);
// 获取列表中指定元素最后一次出现的位置
public int lastIndexOf(Object o);
// 返回一个列表的子列表
public List<E> subList(int fromIndex, int toIndex);
}
```
4. Vector类
Vector是一个基于数组实现的List类，与ArrayList非常类似。不同之处在于Vector是线程安全的，支持同步操作。以下是Vector的常见方法：
```
public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
// 构造函数
public Vector(int initialCapacity, int capacityIncrement);
public Vector(int initialCapacity);
public Vector();
public Vector(Collection<? extends E> c);
// 返回列表中元素的数量
public int size();
// 判断列表是否为空
public boolean isEmpty();
// 判断列表中是否包含指定元素
public boolean contains(Object o);
// 返回列表中所有元素的迭代器
public Iterator<E> iterator();
// 返回列表中所有元素的数组
public Object[] toArray();
// 将列表中所有元素拷贝到指定数组中
public <T> T[] toArray(T[] a);
// 添加指定元素到列表末尾
public synchronized boolean add(E e);
// 删除列表中指定元素
public synchronized boolean remove(Object o);
// 判断列表中是否包含指定集合中的所有元素
public synchronized boolean containsAll(Collection<?> c);
// 向列表中添加指定集合中的所有元素
public synchronized boolean addAll(Collection<? extends E> c);
// 在列表末尾添加指定集合中的所有元素
public boolean
上面的代码中，我们可以看到ArrayList类继承了AbstractList类，并实现了List、RandomAccess、Cloneable、Serializable接口。ArrayList内部使用一个Object数组elementData来存储元素，同时使用一个int类型的变量size来记录ArrayList的大小。
在ArrayList的构造函数中，我们可以看到有两种不同的构造方法。第一种是无参构造方法，它将elementData初始化为DEFAULTCAPACITY_EMPTY_ELEMENTDATA。第二种是有参构造方法，可以传入一个整型参数来指定ArrayList的容量，如果该参数小于等于0，则将elementData初始化为EMPTY_ELEMENTDATA；如果该参数大于0，则会初始化一个大小为initialCapacity的Object数组。
在ArrayList中添加元素的方法有两种：add和add(int index, E element)。add(E e)方法是最常用的添加元素的方法，它将元素添加到ArrayList的末尾。而add(int index, E element)方法则可以将元素添加到ArrayList的特定位置。
在ArrayList中获取元素的方法是get(int index)。在ArrayList中删除元素的方法是remove(int index)。而在ArrayList中修改元素的方法是set(int index, E element)。
在ArrayList中自动扩容的方法是ensureCapacityInternal(int minCapacity)和grow(int minCapacity)。其中，ensureCapacityInternal(int minCapacity)方法是一个私有方法，它用来判断是否需要扩容，如果需要则调用grow(int minCapacity)方法进行扩容。grow(int minCapacity)方法会创建一个新的Object数组，并将原来的Object数组中的元素复制到新数组中，然后将新数组赋值给elementData变量。
以上是一个简单的ArrayList类的源码解析，可以帮助我们更好地理解List接口的实现和内部实现原理。
