java之LinkList、ListIterator、ArrayList学习

1：LinkedList学习

  LinkedList类是链表节点各种操作的实现，LinkedList类实现了一个带有头尾引用的通用型双向链表。

注意，此实现不是同步的。如果多个线程同时访问列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法来“包装”该列表。最好在创建时完成这一操作，以防止对列表进行意外的不同步访问，如下所示：

     List list = Collections.synchronizedList(new LinkedList(...)); 

此类的 iterator 和 listIterator 方法返回的迭代器是快速失败 的：在迭代器创建之后，如果从结构上对列表进行修改，除非通过迭代器自身的remove 或 add 方法，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不冒将来不确定的时间任意发生不确定行为的风险。

注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何硬性保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。

 常见函数

ListIterator<E> listIterator()           返回列表中元素的列表迭代器（以正确的顺序）。  ListIterator<E> listIterator(int index)           返回列表中元素的列表迭代器（以正确的顺序），从列表的指定位置开始。 

 boolean removeAll(Collection<?> c)           从列表中移除指定 collection 中包含的所有元素（可选操作）。 从表中删除所有属于c的元素，如果成功删除就返回true，如果c为空，则抛出NullPointerException boolean retainAll(Collection<?> c)           仅在列表中保留指定 collection 中所包含的元素（可选操作）。 从表中删除所有不属于c的元素，如果成功删除就返回true，如果c为空，则抛出NullPointerException

 List<E> subList(int fromIndex, int toIndex)           返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。 返回从formIndex到toIndex-1位置之间的所有元素

 Object[] toArray()           返回以正确顺序包含列表中的所有元素的数组。 <T> T[]  toArray(T[] a)           返回以正确顺序包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。 

LinkedList是一个双向链表，并且有头节点和尾节点，从下面方法中可以看出：

 

 void addFirst(E o)           将给定元素插入此列表的开头。  void addLast(E o)           将给定元素追加到此列表的结尾。 

 E getFirst()           返回此列表的第一个元素。  E getLast()           返回此列表的最后一个元素。 

 E removeFirst()           移除并返回此列表的第一个元素。  E removeLast()           移除并返回此列表的最后一个元素。 

 Object[] toArray()           以正确顺序返回包含此列表中所有元素的数组。 <T> T[]  toArray(T[] a)           以正确顺序返回包含此列表中所有元素的数组；返回数组的运行时类型即为指定数组的类型。 

2：ListIterator学习

    

public interface ListIterator<E>
extends Iterator<E>

系列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。ListIterator 没有当前元素；它的光标位置 始终位于调用previous() 所返回的元素和调用 next() 所返回的元素之间。在长度为 n 的列表中，有 n+1 个有效的索引值，从 0 到 n（包含）。

          Element(0)   Element(1)   Element(2)   ... Element(n)           ^            ^            ^            ^               ^ Index: 0            1            2            3               n+1 

注意，remove() 和 set(Object) 方法不是 根据光标位置定义的；它们是根据对调用next() 或 previous() 所返回的最后一个元素的操作定义的。

 void add(E o)           将指定的元素插入列表（可选操作）。  boolean hasNext()           以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。  boolean hasPrevious()           如果以反向遍历列表，列表迭代器有多个元素，则返回 true。  E next()           返回列表中的下一个元素。  int nextIndex()           返回对 next 的后续调用所返回元素的索引。  E previous()           返回列表中的前一个元素。  int previousIndex()           返回对 previous 的后续调用所返回元素的索引。  void remove()           从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。  void set(E o)           用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。 

3：ArrayList

     是链表的数组实现，在实际应用中它和Vector是等价的，除了Vector类的方法是同步的，而ArrayList类则不是。与向量相似的是，数组链表也是一个灵活的数组，在插入操作需要时可以自动伸展。

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

List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于Vector 类，除了此类是不同步的。）

size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间 运行，也就是说，添加 n 个元素需要 O(n) 时间。其他所有操作都以线性时间运行（大体上讲）。与用于LinkedList 实现的常数因子相比，此实现的常数因子较低。

每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。

在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。

注意，此实现不是同步的。如果多个线程同时访问一个 ArrayList 实例，而其中至少一个线程从结构上修改了列表，那么它必须 保持外部同步。（结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用Collections.synchronizedList 方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问：

        List list = Collections.synchronizedList(new ArrayList(...)); 

此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的：在创建迭代器之后，除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。

注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误的做法：迭代器的快速失败行为应该仅用于检测 bug。

void ensureCapacity(int minCapacity)           如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。 

protected  void removeRange(int fromIndex, int toIndex)           移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素 

 Object[] toArray()           返回一个按照正确的顺序包含此列表中所有元素的数组。 <T> T[]  toArray(T[] a)           返回一个按照正确的顺序包含此列表中所有元素的数组；返回数组的运行时类型就是指定数组的运行时类型。  void trimToSize()           将此 ArrayList 实例的容量调整为列表的当前大小。