List接口

说明

有序集合（也称为 sequence）。此界面的用户可以精确控制每个元素在列表中的插入位置。用户可以通过整数索引（在列表中的位置）访问元素，并在列表中搜索元素。
与集合不同，列表通常允许重复元素。更正式地说，列表通常允许元素对 e1 和 e2使得e1.equals(e2)，并且如果它们允许 null，它们通常允许多个 null 元素元素。有人可能希望通过在用户尝试插入它们时抛出运行时异常来实现一个禁止重复的列表，这并非不可想象，但我们希望这种用法很少见。
List 接口在iterator, add的契约上放置了额外的规定，超出了 Collection 接口中指定的规定remove、equals 和hashCode 方法。为方便起见，此处还包含了其他继承方法的声明。
List 接口提供了四种用于对列表元素进行位置（索引）访问的方法。列表（如 Java 数组）是从零开始的。请注意，对于某些实现（例如，LinkedList类），这些操作的执行时间可能与索引值成正比。因此，如果调用者不知道实现，则迭代列表中的元素通常比通过它进行索引更可取。
List接口提供了一个特殊的迭代器，称为ListIterator，除了 Iterator接口的正常操作之外，它允许元素插入和替换以及双向访问提供。提供了一种方法来获取从列表中指定位置开始的列表迭代器。
List接口提供两种方法来搜索指定对象。从性能的角度来看，应谨慎使用这些方法。在许多实现中，它们将执行代价高昂的线性搜索。
List接口提供了两种方法来有效地在列表中的任意点插入和删除多个元素。 注意：虽然它是允许的将自身包含为元素的列表，建议格外小心：equals和hashCode 方法不再在这样的列表上明确定义。
某些列表实现对它们可能包含的元素有限制。例如，有些实现禁止空元素，有些实现对其元素的类型有限制。尝试添加不合格的元素会引发未经检查的异常，通常是 NullPointerException 或 ClassCastException。尝试查询不合格元素的存在可能会引发异常，或者可能只是返回 false；一些实现会表现出前一种行为，而另一些会表现出后者。更一般地，尝试对不合格元素执行操作，其完成不会导致将不合格元素插入到列表中，这可能会引发异常，也可能会成功，具体取决于实现的选择。在此接口的规范中，此类异常被标记为“可选”。

源码方法解析

    int size();  //返回list中元素的数量

   
    boolean isEmpty(); //返回true说明list为空，否则含有元素

   
    boolean contains(Object o); //list中存在元素o，至少存在一个

   
    Iterator<E> iterator();//以适当的顺序返回此列表中元素的迭代器。

  
    Object[] toArray();  //以适当的顺序（从第一个元素到最后一个元素）返回一个包含此列表中所有元素的数组。 返回的数组将是“安全的”，因为此列表不维护对它的引用。 （换句话说，即使此列表由数组支持，此方法也必须分配一个新数组）。因此调用者可以自由地修改返回的数组。 此方法充当基于数组和基于集合的 API 之间的桥梁。

  
    <T> T[] toArray(T[] a); //以适当的顺序（从第一个元素到最后一个元素）返回一个包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的类型。如果列表适合指定的数组，则在其中返回。否则，将使用指定数组的运行时类型和此列表的大小分配一个新数组。 如果列表适合指定的数组，并且有剩余空间（即，数组的元素比列表多），则将紧跟列表末尾的数组元素设置为 null. （如果调用者知道列表不包含任何空元素，这在确定列表的长度时很有用 only。） 与  toArray()方法一样，此方法起作用作为基于数组和基于集合的 API 之间的桥梁。此外，该方法允许对输出数组的运行时类型进行精确控制，并且在某些情况下可用于节省分配成本。 


   
    boolean add(E e);//将指定的元素附加到此列表的末尾（可选操作）。支持此操作的列表可能会限制可以添加到此列表中的元素。特别是，一些列表会拒绝添加空元素，而另一些列表则会对可能添加的元素类型施加限制。列表类应在其文档中明确指定对可以添加哪些元素的任何限制。

    
    boolean remove(Object o);//从此列表中删除第一次出现的指定元素（如果存在）（可选操作）。如果此列表不包含该元素，则它保持不变。更正式地，删除具有最低索引 i的元素，使得(o==null ? get(i)==null : o.equals(get(i)))(如果存在这样的元素）。如果此列表包含指定的元素（或等效地，如果此列表因调用而更改），则返回 true


   
    boolean containsAll(Collection<?> c); //如果此列表包含指定集合的​​所有元素，则返回 true。

   
    boolean addAll(Collection<? extends E> c); //将指定集合中的所有元素附加到此列表的末尾，按照它们由指定集合的​​迭代器返回的顺序（可选操作）。如果在操作进行时修改了指定的集合，则此操作的行为未定义。 （请注意，如果指定的集合是这个列表，并且它是非空的，则会发生这种情况。）

  
    boolean addAll(int index, Collection<? extends E> c);//将指定集合中的所有元素插入此列表的指定位置（可选操作）。将当前在该位置的元素（如果有）和任何后续元素向右移动（增加它们的索引）。新元素将按照指定集合的​​迭代器返回的顺序出现在此列表中。如果在操作进行时修改了指定的集合，则此操作的行为未定义。 （请注意，如果指定的集合是这个列表，并且它是非空的，则会发生这种情况。）

   
    boolean removeAll(Collection<?> c);//从此列表中删除包含在指定集合中的所有元素（可选操作）。

    
    boolean retainAll(Collection<?> c);//仅保留此列表中包含在指定集合中的元素（可选操作）。换句话说，从该列表中删除所有未包含在指定集合中的元素。

   
    default void replaceAll(UnaryOperator<E> operator) {//用将运算符应用于该元素的结果替换此列表的每个元素。操作员抛出的错误或运行时异常被转发给调用者。
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }

    
    @SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator<? super E> c) {//根据指定的顺序排列此列表
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

   
    void clear();//清除列表中所有的元素


   
    boolean equals(Object o);//比较指定的对象与此列表是否相等。返回true 当且仅当指定的对象也是一个列表，两个列表的大小相同，并且两个列表中所有对应的元素对相等。 （两个元素 e1 和 e2equal if (e1==null ? e2==null : e1.equals(e2))) 换句话说，如果两个列表以相同的顺序包含相同的元素，则它们被定义为相等。此定义可确保 equals 方法在 List 接口的不同实现中正常工作。

  
    int hashCode();//返回列表的哈希值


   
    E get(int index);//返回下标为index的元素值

   
    E set(int index, E element);//将下表为index的值替换为element

 
    void add(int index, E element);//在此列表中的指定位置插入指定元素（可选操作）。将当前在该位置的元素（如果有）和任何后续元素向右移动（向它们的索引添加一个）。

   
    E remove(int index);//移除此列表中指定位置的元素（可选操作）。将任何后续元素向左移动（从它们的索引中减去一个）。返回从列表中删除的元素。


   
    int indexOf(Object o);//返回此列表中指定元素第一次出现的索引，如果此列表不包含该元素，则返回 -1。更正式地，返回最低索引 i使得(o==null ? get(i)==null : o.equals(get(i)))，或 -1如果没有这样的索引。

  
    int lastIndexOf(Object o);//返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回 -1。更正式地，返回最高索引 i 使得 <tt>(o==null ? get(i)==null : o.equals(get(i)))，或 -1如果没有这样的索引。


   
    ListIterator<E> listIterator();//返回此列表中元素的列表迭代器（按适当的顺序）。

    
    ListIterator<E> listIterator(int index);//返回此列表中元素的列表迭代器（以适当的顺序），从列表中的指定位置开始。指定的索引指示初始调用 {@link ListIteratornext next} 将返回的第一个元素。对 {@link ListIteratorprevious previous} 的初始调用将返回指定索引减一的元素

  
    List<E> subList(int fromIndex, int toIndex);//返回此列表中指定的 fromIndex（包含）和toIndex（不包含）之间的部分的视图。 （如果 fromIndex 和toIndex 相等，则返回的列表为空。）返回的列表由此列表支持，因此返回列表中的非结构性更改会反映在此列表中，反之亦然。返回的列表支持此列表支持的所有可选列表操作。此方法消除了对显式范围操作（数组通常存在的排序）的需要。通过传递子列表视图而不是整个列表，任何需要列表的操作都可以用作范围操作。


    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }
}

相关方法使用

package yuanMa;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class ListF {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        System.out.println(list.size());
        System.out.println(list.get(2));
        //直接利用for循环进行遍历
        for(int i = 0 ; i < list.size();i++){
            System.out.println(list.get(i));
        }
        //利用foreach进行遍历
        for (Object o: list
             ) {
            System.out.println(o);
        }
        //利用迭代器进行遍历
        Iterator it = list.iterator();
        while(it.hasNext()){
            Object o = it.next();
            System.out.println(o);
        }
        //转换数组
        Object[] str = new String[list.size()];
        str = list.toArray();
        System.out.println(Arrays.toString(str));

    }

}