List

 

public interface List<E> extends Collection<E>

//接口中的成员变量只能是 public static final 类型的。

•  接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
• 4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

1.  int size();

 Returns the number of elements in this list.  If this list contains
     * more than <tt>Integer.MAX_VALUE</tt> elements, returns
     * <tt>Integer.MAX_VALUE</tt>.

2.  boolean isEmpty();

Returns <tt>true</tt> if this list contains no elements.

3.  boolean contains(Object o);

Returns <tt>true</tt> if this list contains the specified element.
     * More formally, returns <tt>true</tt> if and only if this list contains
     * at least one element <tt>e</tt> such that
     * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.

4.Iterator<E> iterator();

     Returns an iterator over the elements in this list in proper sequence.     

          4.1   boolean hasNext();

                    Returns {@code true} if the iteration has more elements.

         4.2     E next();

           Returns the next element in the iteration.

        4.3  default void remove() {
                 throw new UnsupportedOperationException("remove");
    }
 

             Removes from the underlying collection the last element returned
     * by this iterator (optional operation).  This method can be called
     * only once per call to {@link #next}.  The behavior of an iterator
     * is unspecified if the underlying collection is modified while the
     * iteration is in progress in any way other than by calling this
     * method.

5. Object[] toArray();

     * Returns an array containing all of the elements in this list in proper
     * sequence (from first to last element).
     *
     * <p>The returned array will be "safe" in that no references to it are
     * maintained by this list.  (In other words, this method must
     * allocate a new array even if this list is backed by an array).
     * The caller is thus free to modify the returned array.

6.    boolean add(E e);

Appends the specified element to the end of this list (optional
     * operation).
     *
     * <p>Lists that support this operation may place limitations on what
     * elements may be added to this list.  In particular, some
     * lists will refuse to add null elements, and others will impose
     * restrictions on the type of elements that may be added.  List
     * classes should clearly specify in their documentation any restrictions
     * on what elements may be added.

 

7.boolean remove(Object o);

Removes the first occurrence of the specified element from this list,
     * if it is present (optional operation).  If this list does not contain
     * the element, it is unchanged.  More formally, removes the element with
     * the lowest index <tt>i</tt> such that
     * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>
     * (if such an element exists).  Returns <tt>true</tt> if this list
     * contained the specified element (or equivalently, if this list changed
     * as a result of the call).

 

8.  boolean containsAll(Collection<?> c);

Returns <tt>true</tt> if this list contains all of the elements of the
     * specified collection.

 

9.void clear();

 Removes all of the elements from this list (optional operation).
     * The list will be empty after this call returns.

 

10.int hashCode();

* Returns the hash code value for this list.  The hash code of a list
     * is defined to be the result of the following calculation:
     *     int hashCode = 1;
     *     for (E e : list)
     *         hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());

 

11.get(int index);

Returns the element at the specified position in this list.

12.set(int index, E element);

Replaces the element at the specified position in this list with the
     * specified element (optional operation).

13.    void add(int index, E element);

Inserts the specified element at the specified position in this list
     * (optional operation).  Shifts the element currently at that position
     * (if any) and any subsequent elements to the right (adds one to their
     * indices).
     

14.remove(int index);

 Removes the element at the specified position in this list (optional
     * operation).  Shifts any subsequent elements to the left (subtracts one
     * from their indices).  Returns the element that was removed from the
     * list.

 

15. int indexOf(Object o);

Returns the index of the first occurrence of the specified element
     * in this list, or -1 if this list does not contain the element.
     * More formally, returns the lowest index <tt>i</tt> such that
     * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
     * or -1 if there is no such index.

16. ListIterator<E> listIterator();

 

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

* Returns a view of the portion of this list between the specified
     * <tt>fromIndex</tt>, inclusive, and <tt>toIndex</tt>, exclusive.  (If
     * <tt>fromIndex</tt> and <tt>toIndex</tt> are equal, the returned list is
     * empty.)  The returned list is backed by this list, so non-structural
     * changes in the returned list are reflected in this list, and vice-versa.
     * The returned list supports all of the optional list operations supported
     * by this list.<p>

截取一部分，不包括第一个索引值