Java集合类之——List篇

List接口

• List继承了Collection，是有序的列表。
• 实现类有ArrayList、Vector、LinkedList、Stack等
  • ArrayList是基于数组实现的，是一个数组队列。可以动态的增加容量！
  • Vector是基于数组实现的，是一个矢量队列，是线程安全的！
  • LinkedList是基于链表实现的，是一个双向循环列表。可以被当做堆栈使用！
  • Stack是基于数组实现的，是栈，它继承与Vector，特性是FILO（先进后出）

实用场景
- 如果使用到队列，栈，链表，可以使用List。
- 当集合中对插入速度要求不高，但要求访问元素数据的速度，则使用ArrayList
- 当集合中对访问元素数据的速度要求不高，但是对插入和删除数据速度要求高，则使用LinkedList
- 当集合中有多线程对集合元素进行操作时候，此时为了线程安全可以使用Vector！但是BVector现在一般不再使用。
- 当集合中有需求是希望后保存的数据先读取出来，使用Stack

ArrayList[重点]

• 数组结构实现，查询快、增删慢；
• JDK1.2版本，运行效率快，线程不安全；

ArrayList的简介

• ArrayList基于数组实现，是一个动态的数组队列。但是它和数组又不一样，容量可以自动增长。
• ArrayList继承了AbstractList，实现了RandomAccess、Cloneable和Serializable接口
• 集成了AbstractList，AbstractList又继承了AbstractCollection实现了List接口，它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能
• 实现了RandomAccess接口，提供了随机访问功能，实际上就是通过下标序号进行快速访问。
• 实现了Serializable接口，支持序列化，也就意味了ArrayList能够通过序列化传输。

ArrayList 的一些方法

返回值	方法
boolean	add(E object)
boolean	addAll(Collection<? extends E> collection)
void	clear()
boolean	contains(Object object)
boolean	containsAll(Collection<?> collection)
boolean	equals(Object object)
int	hashCode()
boolean	isEmpty()
Iterator	iterator()
boolean	remove(Object object)
boolean	removeAll(Collection<?> collection)
Object	clone()
List	subList(int start, int end)
E	set(int location, E object)
E	remove(int location)
ListIterator	listIterator()
ListIterator	listIterator(int location)
int	lastIndexOf(Object object)
int	indexOf(Object object)
E	get(int location)
boolean	addAll(int location, Collection<? extends E> collection)
void	add(int location, E object)
Object[]	toArray()
T[]	toArray(T[] array)
int	size()
boolean	retainAll(Collection<?> collection)
void	trimToSize()
void	removeRange(int fromIndex, int toIndex)
void	ensureCapacity(int minimumCapacity)

Vector

• 数组结构实现，查询快、增删慢；
• JDK1.0版本，运行效率慢，线程安全；
• Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。
• Vector 继承了AbstractList，实现了List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。
• vector实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在Vector中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。
• Vector 实现Serializable接口，支持序列化。

synchronized boolean        add(E object)
             void           add(int location, E object)
synchronized boolean        addAll(Collection<? extends E> collection)
synchronized boolean        addAll(int location, Collection<? extends E> collection)
synchronized void           addElement(E object)
synchronized int            capacity()
             void           clear()
synchronized Object         clone()
             boolean        contains(Object object)
synchronized boolean        containsAll(Collection<?> collection)
synchronized void           copyInto(Object[] elements)
synchronized E              elementAt(int location)
             Enumeration<E> elements()
synchronized void           ensureCapacity(int minimumCapacity)
synchronized boolean        equals(Object object)
synchronized E              firstElement()
             E              get(int location)
synchronized int            hashCode()
synchronized int            indexOf(Object object, int location)
             int            indexOf(Object object)
synchronized void           insertElementAt(E object, int location)
synchronized boolean        isEmpty()
synchronized E              lastElement()
synchronized int            lastIndexOf(Object object, int location)
synchronized int            lastIndexOf(Object object)
synchronized E              remove(int location)
             boolean        remove(Object object)
synchronized boolean        removeAll(Collection<?> collection)
synchronized void           removeAllElements()
synchronized boolean        removeElement(Object object)
synchronized void           removeElementAt(int location)
synchronized boolean        retainAll(Collection<?> collection)
synchronized E              set(int location, E object)
synchronized void           setSize(int length)
synchronized int            size()
synchronized List<E>        subList(int start, int end)
synchronized <T> T[]        toArray(T[] contents)
synchronized Object[]       toArray()
synchronized String         toString()

• [注意] ： Vector跟ArrayList基本一致知识Vector是线程安全的方法多用synchronize修饰，所以速度比ArrayList慢很多

LinkedList

• 数组结构实现，查询慢、增删快；
• JDK1.2版本，运行效率快，线程不安全；
• LinkedList是基于链表实现的，从源码可以看出是一个双向链表。除了当做链表使用外，它也可以被当作堆栈、队列或双端队列进行操作。是线程不安全。
• LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。
• LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。

boolean add(E e) 
     将指定元素添加到此列表的结尾。
 void   add(int index, E element) 
     在此列表中指定的位置插入指定的元素。
 boolean    addAll(Collection<? extends E> c) 
     添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
 boolean    addAll(int index, Collection<? extends E> c) 
      将指定 collection 中的所有元素从指定位置开始插入此列表。
 void   addFirst(E e) 
      将指定元素插入此列表的开头。
 void   addLast(E e) 
     将指定元素添加到此列表的结尾。
 void   clear() 
    从此列表中移除所有元素。
 Object clone() 
     返回此 LinkedList 的浅表副本。
 boolean    contains(Object o) 
     如果此列表包含指定元素，则返回 true。
 Iterator<E>    descendingIterator() 
     返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
 E  element() 
    获取但不移除此列表的头（第一个元素）。
 E  get(int index) 
   返回此列表中指定位置处的元素。
 E  getFirst() 
    返回此列表的第一个元素。
 E  getLast() 
    返回此列表的最后一个元素。
 int    indexOf(Object o) 
    返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
 int    lastIndexOf(Object o) 
    返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
 ListIterator<E>    listIterator(int index) 
   返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。
 boolean    offer(E e) 
    将指定元素添加到此列表的末尾（最后一个元素）。
 boolean    offerFirst(E e) 
    在此列表的开头插入指定的元素。
 boolean    offerLast(E e) 
    在此列表末尾插入指定的元素。
 E  peek() 
    获取但不移除此列表的头（第一个元素）。
 E  peekFirst() 
    获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
 E  peekLast() 
   获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
 E  poll() 
    获取并移除此列表的头（第一个元素）
 E  pollFirst() 
     获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
 E  pollLast() 
     获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
 E  pop() 
    从此列表所表示的堆栈处弹出一个元素。
 void   push(E e) 
    将元素推入此列表所表示的堆栈。
 E  remove() 
    获取并移除此列表的头（第一个元素）。
 E  remove(int index) 
   移除此列表中指定位置处的元素。
 boolean    remove(Object o) 
     从此列表中移除首次出现的指定元素（如果存在）。
 E  removeFirst() 
    移除并返回此列表的第一个元素。
 boolean    removeFirstOccurrence(Object o) 
     从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
 E  removeLast() 
    移除并返回此列表的最后一个元素。
 boolean    removeLastOccurrence(Object o) 
     从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。
 E  set(int index, E element) 
    将此列表中指定位置的元素替换为指定的元素。
 int    size() 
    返回此列表的元素数。
 Object[]   toArray() 
    返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。
<T> T[] toArray(T[] a) 
     返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；返回数组的运行时类型为指定数组的类型。

• LinkedList的实现是基于双向循环链表，实现的 List和Deque 接口。实现所有可选的列表操作，并允许所有元素。
• LinkedList是非线程安全的，只在单线程下适合使用。
• 这个类的iterator和返回的迭代器listIterator方法是fail-fast ，要注意ConcurrentModificationException 。
• LinkedList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了Cloneable接口，能被克隆。
• 在查找和删除某元素时，都分为该元素为null和不为null两种情况来处理，LinkedList中允许元素为null。
• 由于是基于列表的，LinkedList的没有扩容方法，默认加入元素是尾部自动扩容。
• LinkedList还实现了栈和队列的操作方法，因此也可以作为栈、队列和双端队列来使用，如peek 、push、pop等方法。
• LinkedList是基于链表实现的，因此插入删除效率高，查找效率非常低（

Stack

• Stack 类表示后进先出（LIFO）的对象堆栈。
• 提供 push 和 pop 操作与 peek 方法、 empty 方法、search 方法。
• 继承自Vector,那么它的实现原理是以数组实现堆栈的。
• 是线程安全的

boolean empty() 
      测试堆栈是否为空。
E   peek() 
      查看堆栈顶部的对象，但不从堆栈中移除它。
E   pop() 
      移除堆栈顶部的对象，并作为此函数的值返回该对象。
E   push(E item) 
      把项压入堆栈顶部。
int search(Object o) 
      返回对象在堆栈中的位置，以 1 为基数。

• Stack实际上也是通过数组去实现的。实际调用的实现方法都是Vector中的方法！

• push时(即，将元素推入栈中)，是通过将元素追加的数组的末尾中。

• peek时(即，取出栈顶元素，不执行删除)，是返回数组末尾的元素。

• pop时(即，取出栈顶元素，并将该元素从栈中删除)，是取出数组末尾的元素，然后将该元素从数组中删除。