java.util.List API解读

list的API 如下：

下面是我对这段API的翻译

An ordered collection (also known as a sequence).
一个有序的集合（也被称为序列）
The user of this interface has precise control over where in the list each element is inserted.
这个接口的 使用者对list中每个元素的插入位置有着准确的控制。
The user can access elements by their integer index (position in the list), and search for elements in the list.
使用者可以通过索引（Interger类型）来获取元素，查找元素。

Unlike sets, lists typically allow duplicate elements.
和set不同，list允许重复元素。
More formally, lists typically allow pairs of elements e1 and e2 such that e1.equals(e2),
更正式的说法是，list允许e1.equals(e2),
and they typically allow multiple null elements if they allow null elements at all.
同样，list中也允许存在null元素。 
It is not inconceivable that someone might wish to implement a list that prohibits duplicates, by throwing runtime exceptions when the user attempts to insert them, but we expect this usage to be rare.
当然，用户可以自定义list，使得这个list不接受null元素（元素是null就抱空指针错误或者做其他处理）。

The List interface places additional stipulations,beyond those specified in the Collection interface, on the contracts of the iterator, add, remove, equals, and hashCode methods. 
Declarations for other inherited methods are also included here for convenience.
除了collection接口中明确需要继承的方法（iterator,add,remove,equals,hashcode）之外，list接口还增加了其他的接口，这些接口为list的使用提供了便利。

The List interface provides four methods for positional (indexed) access to list elements.
list接口提供了四个方法来通过索引获取元素。 
Lists (like Java arrays) are zero based.
list和java中的数组一样是从零开始。
Note that these operations may execute in time proportional to the index value for some implementations (the LinkedList class, for example).
需要注意的是这些操作执行的时间可能跟index的值成比例（比如LinkedList ）
Thus, iterating over the elements in a list is typically preferable to indexing through it if the caller does not know the implementation.
因此，如果调用者不知道实现，则通过迭代列表中的元素通常优先于索引。
 

The List interface provides a special iterator, called a ListIterator,
list接口提供了一个特殊的迭代器，称为ListIterator. 
that allows element insertion and replacement, and bidirectional access in addition to the normal operations that the Iterator interface provides. 
这允许元素插入和替换，以及Iterator接口提供的常规操作之外的双向访问。
A method is provided to obtain a list iterator that starts at a specified position in the list.
从一个list中的特定位置开始的Iterator可以通过list中提供的方法获取。

The List interface provides two methods to search for a specified object.
list接口提供两个方法来查找指定的对象。
From a performance standpoint, these methods should be used with caution.
为了性能要求，这些方法必须使用警告。
In many implementations they will perform costly linear searches.
在很多实现中，他们都是非常耗时的线性查找。

The List interface provides two methods to efficiently insert and remove multiple elements at an arbitrary point in the list.
List接口提供了两种方法，可以在列表中的任意点高效地插入和删除多个元素。

Note: While it is permissible for lists to contain themselves as elements, extreme caution is advised: the equals and hashCode methods are no longer well defined on such a list.
注意：尽管列表允许将其自身作为元素，但建议您非常小心：equals和hashCode方法在这样的列表中不再被很好地定义。

Some list implementations have restrictions on the elements that they may contain.
有一些list的实现在它们能够包含的元素上有一些限制。
For example, some implementations prohibit null elements, and some have restrictions on the types of their elements.
比如，有些list不能有null元素，有些list的元素类型被限制。 
Attempting to add an ineligible element throws an unchecked exception, typically NullPointerException or ClassCastException.
尝试将不符合要求的元素加入到list中会抛出异常，通常是空指针异常 或者 ClassCastException。
Attempting to query the presence of an ineligible element may throw an exception, or it may simply return false;
尝试查询一个不符合要求的元素
some implementations will exhibit the former behavior and some will exhibit the latter.
有些实现会禁止之前的行为，有些则会禁止某些字母。
More generally, attempting an operation on an ineligible element whose completion would not result in the insertion of an ineligible element into the list may throw an exception or it may succeed, at the option of the implementation.
通常，尝试操作不符合要求的元素将不会导致不符合要求的元素插入到队列中，而是导致异常，当然也有可能成功，这取决于具体的实现。
Such exceptions are marked as "optional" in the specification for this interface.
在这个接口规范中这些异常被标注为可选择的。

This interface is a member of the Java Collections Framework.
这个接口是java集合框架中的一员。

总结一下，主要说了以下几点：
1、list是一个有序的集合（也是被称为序列），和set不一样，list中允许重复元素的存在。

2、list的使用者对元素的插入位置（索引）有着准确的控制，通过索引可以获取元素。

3、list提供了各种方法来方便我们对其中的元素操作

4、list是java集合框架的一员

说得太笼统，具体还是需要看API。

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

接口中定义的方法

    //返回list中的元素个数
    int size();        
    
    //判断list中是否包含元素，如果不包含返回true
    boolean isEmpty();        
    
    //判断list中是否包含某个特定的对象
    boolean contains(Object o);    
    
    //以正确的顺序返回list中元素的迭代器    
    Iterator<E> iterator();
    
    //返回一个包含list中所有元素的数组，数组中元素的顺序和list中的顺序一样
    //这个方法可以当做array-based 和 collection-based API之间的桥梁
    Object[] toArray();        
    
    //返回一个包含list中所有元素的数组，数组中元素的顺序和list中的顺序一样
    //array数组的类型是确定的。如果指定的array大小不足，这个方法将会生成一个新的数组用于返回
    //新数组的类型和运行时的数组类型一样
    <T> T[] toArray(T[] a);
    
    //在list的末尾插入元素（实现类可以选择插入的位置）
    boolean add(E e);
    
    //如果指定元素存在list中，移除list中第一次出现的指定元素（实现类可以选择具体的实现）
    boolean remove(Object o);
    
    //判断list中是否包含某个集合
    boolean containsAll(Collection<?> c);
    
    //将指定集合中的所有元素加到list的末尾
    boolean addAll(Collection<? extends E> c);
    
    //在指定位置插入指定集合
    boolean addAll(int index, Collection<? extends E> c);
    
    //删除list中包含的Collection中的所有元素
    boolean removeAll(Collection<?> c);
    
    //保留list中包含的Collection中的所有元素
    boolean retainAll(Collection<?> c);
    
    //将该列表的每个元素替换为将该运算符应用于该元素的结果。
    default void replaceAll(UnaryOperator<E> operator);
    
    //对list中的元素排列
    default void sort(Comparator<? super E> c);
    
    //删除list中的所有元素
    void clear();
    
    boolean equals(Object o);
    
    int hashCode();
    
    //根据索引获取list中的元素
    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的list 迭代器
    ListIterator<E> listIterator();
    
    //从指定位置返回list的迭代器
    ListIterator<E> listIterator(int index);
    
    //返回list的子list
    List<E> subList(int fromIndex, int toIndex);
    
    //Creates a {@link Spliterator} over the elements in this list.
    default Spliterator<E> spliterator()