JAVA集合框架之List接口实现类

上一篇博客《JAVA集合框架之Set接口实现类》中介绍了Set接口的相关实现类，这一篇将介绍List接口的实现类。

java.util.ArrayList< E >

ArrayList有点类似于数组，相比较于数组而言，ArrayList可以动态的更改元素个数，相对于数组较为灵活。
每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。
在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。

构造方法

方法名	说明
ArrayList()	构造一个初始容量为 10 的空列表
ArrayList(Collection< ? extends E> c)	构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection的迭代器返回它们的顺序排列的
ArrayList(int initialCapacity)	构造一个具有指定初始容量的空列表

方法摘要

返回值	方法名	说明
boolean	add(E e)	将指定的元素添加到此列表的尾部
void	add(int index, E element)	将指定的元素插入此列表中的指定位置
boolean	addAll(Collection c)	按照指定 collection 的迭代器所返回的元素顺序，将该collection中的所有元素添加到此列表的尾部
boolean	addAll(int index, Collection c)	从指定的位置开始，将指定 collection 中的所有元素插入到此列表中
void	clear()	移除此列表中的所有元素
Object	clone()	返回此 ArrayList 实例的浅表副本
boolean	contains(Object o)	如果此列表中包含指定的元素，则返回 true
void	ensureCapacity(int minCapacity)	如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数
E	get(int index)	返回此列表中指定位置上的元素
int	indexOf(Object o)	返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1
boolean	isEmpty()	如果此列表中没有元素，则返回 true
int	lastIndexOf(Object o)	返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1
E	remove(int index)	移除此列表中指定位置上的元素
boolean	remove(Object o)	移除此列表中首次出现的指定元素（如果存在）
protected void	removeRange(int fromIndex, int toIndex)	移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素
E	set(int index, E element)	用指定的元素替代此列表中指定位置上的元素
int	size()	返回此列表中的元素数
Object[]	toArray()	按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组
< T > T[]	toArray(T[] a)	按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型
void	trimToSize()	将此 ArrayList 实例的容量调整为列表的当前大小

使用示例

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListDemo
{
   public static void main(String[] args)
   {
      // 创建一个ArrayList对象，<String>为泛型，表明ArrayList中的元素必须是String类型
      ArrayList<String> list = new ArrayList<String>();
      // 添加元素
      list.add("jiang");
      list.add("gu");
      list.add("jin");
      System.out.println("集合中的元素个数为：" + list.size());
      // 判断集合中是否包含指定元素
      System.out.println(list.contains("jiang"));
      // 遍历集合中的元素
      System.out.println("集合中的元素为(迭代器Iterator)：");
      Iterator<String> iterator = list.iterator();
      while (iterator.hasNext())
      {
         System.out.println(iterator.next());
      }
      System.out.println("集合中的元素为(foreach)：");
      for (String item : list)
      {
         System.out.println(item);
      }
   }
}

java.util.Vector< E >

Vector和ArrayList的区别在于Vector是线程同步的。
Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。
每个向量会试图通过维护 capacity 和 capacityIncrement 来优化存储管理。capacity 始终至少应与向量的大小相等；这个值通常比后者大些，因为随着将组件添加到向量中，其存储将按capacityIncrement 的大小增加存储块。应用程序可以在插入大量组件前增加向量的容量；这样就减少了增加的重分配的量。

构造方法

方法名	说明
Vector()	构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零
Vector(Collection< ? extends E> c)	构造一个包含指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列
Vector(int initialCapacity)	使用指定的初始容量和等于零的容量增量构造一个空向量
Vector(int initialCapacity, int capacityIncrement)	使用指定的初始容量和容量增量构造一个空的向量

方法摘要

返回值	方法名	说明
boolean	add(E e)	将指定元素添加到此向量的末尾
void	add(int index, E element)	在此向量的指定位置插入指定的元素
boolean	addAll(Collection c)	将指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的顺序添加这些元素
boolean	addAll(int index, Collection c)	在指定位置将指定 Collection 中的所有元素插入到此向量中
void	addElement(E obj)	将指定的组件添加到此向量的末尾，将其大小增加 1
int	capacity()	返回此向量的当前容量
void	clear()	从此向量中移除所有元素
Object	clone()	返回向量的一个副本
boolean	contains(Object o)	如果此向量包含指定的元素，则返回 true
boolean	containsAll(Collection c)	如果此向量包含指定 Collection 中的所有元素，则返回 true
void	copyInto(Object[] anArray)	将此向量的组件复制到指定的数组中
E	elementAt(int index)	返回指定索引处的组件
Enumeration< E >	elements()	返回此向量的组件的枚举
void	ensureCapacity(int minCapacity)	增加此向量的容量（如有必要），以确保其至少能够保存最小容量参数指定的组件数
boolean	equals(Object o)	比较指定对象与此向量的相等性
E	firstElement()	返回此向量的第一个组件（位于索引 0) 处的项）
E	get(int index)	返回向量中指定位置的元素
int	hashCode()	返回此向量的哈希码值
int	indexOf(Object o)	返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回 -1
int	indexOf(Object o, int index)	返回此向量中第一次出现的指定元素的索引，从 index 处正向搜索，如果未找到该元素，则返回 -1
void	insertElementAt(E obj, int index)	将指定对象作为此向量中的组件插入到指定的 index 处
boolean	isEmpty()	测试此向量是否不包含组件
E	lastElement()	返回此向量的最后一个组件
int	lastIndexOf(Object o)	返回此向量中最后一次出现的指定元素的索引；如果此向量不包含该元素，则返回 -1
int	lastIndexOf(Object o, int index)	返回此向量中最后一次出现的指定元素的索引，从 index 处逆向搜索，如果未找到该元素，则返回 -1
E	remove(int index)	移除此向量中指定位置的元素
boolean	remove(Object o)	移除此向量中指定元素的第一个匹配项，如果向量不包含该元素，则元素保持不变
boolean	removeAll(Collection c)	从此向量中移除包含在指定 Collection 中的所有元素
void	removeAllElements()	从此向量中移除全部组件，并将其大小设置为零
boolean	removeElement(Object obj)	从此向量中移除变量的第一个（索引最小的）匹配项
void	removeElementAt(int index)	删除指定索引处的组件
protected void	removeRange(int fromIndex, int toIndex)	从此 List 中移除其索引位于fromIndex（包括）与toIndex（不包括）之间的所有元素
boolean	retainAll(Collection c)	在此向量中仅保留包含在指定 Collection 中的元素
E	set(int index, E element)	用指定的元素替换此向量中指定位置处的元素
void	setElementAt(E obj, int index)	将此向量指定 index 处的组件设置为指定的对象
void	setSize(int newSize)	设置此向量的大小
int	size()	返回此向量中的组件数
List< E >	subList(int fromIndex, int toIndex)	返回此 List 的部分视图，元素范围为从 fromIndex（包括）到 toIndex（不包括）
Object[]	toArray()	返回一个数组，包含此向量中以恰当顺序存放的所有元素
< T > T[]	toArray(T[] a)	返回一个数组，包含此向量中以恰当顺序存放的所有元素；返回数组的运行时类型为指定数组的类型
String	toString()	返回此向量的字符串表示形式，其中包含每个元素的 String 表示形式
void	trimToSize()	对此向量的容量进行微调，使其等于向量的当前大小

使用示例

import java.util.Iterator;
import java.util.Vector;

public class VectorDemo
{
   public static void main(String[] args)
   {
      // 创建一个Vector对象，<String>为泛型，表明Vector中的元素必须是String类型
      Vector<String> list = new Vector<String>();
      // 添加元素，线程同步
      list.add("jiang");
      list.add("gu");
      list.add("jin");
      System.out.println("集合中的元素个数为：" + list.size());
      // 判断集合中是否包含指定元素
      System.out.println(list.contains("jiang"));
      // 遍历集合中的元素
      System.out.println("集合中的元素为(迭代器Iterator)：");
      Iterator<String> iterator = list.iterator();
      while (iterator.hasNext())
      {
         System.out.println(iterator.next());
      }
      System.out.println("集合中的元素为(foreach)：");
      for (String item : list)
      {
         System.out.println(item);
      }
   }
}

通过上面的例子，我们发现Vector的使用和ArrayList基本是一样的，只是Vector在对元素进行操作时是线程同步的。在线程并发的时候，我们应该选择Vector而非ArrayList。

java.util.LinkedList< E >

与上面介绍的类一样，LinkedList也实现了List接口，在其内部以链表的方式维护元素，LinkedList具备List接口的所有方法，另外，LinkedList类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。

构造方法

方法名	说明
LinkedList()	构造一个空列表
LinkedList(Collection< ? extends E> c)	构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列

方法摘要

返回值	方法名	说明
boolean	add(E e)	将指定元素添加到此列表的结尾
void	add(int index, E element)	在此列表中指定的位置插入指定的元素
boolean	addAll(Collection c)	添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序
boolean	addAll(int index, Collection 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)	返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；返回数组的运行时类型为指定数组的类型

使用示例

import java.util.LinkedList;

public class LinkedListDemo
{
   public static void main(String[] args)
   {
      // 创建一个LinkedList对象，<String>为泛型，表明LinkedList中的元素必须是String类型
      LinkedList<String> list = new LinkedList<String>();
      // List接口中的通用方法不再列举
      // 将指定元素添加到此列表的结尾
      list.add("jiang");
      list.add("gu");
      list.add("jin");
      while (!list.isEmpty())
      {
         // 获取并移除此列表的头（第一个元素）
         System.out.println(list.poll());
      }
   }
}

java.util.Stack< E >

Stack类继承自Vector，所以Stack和Vector一样也是线程安全的。Stack 类表示后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展 ，允许将向量视为堆栈。它提供了通常的 push 和 pop 操作，以及取堆栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search 方法。

构造方法

方法名	说明
Stack()	创建一个空堆栈

方法摘要

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

使用示例

import java.util.Stack;

public class StackDemo
{
   public static void main(String[] args)
   {
      // 创建一个Stack对象，<String>为泛型，表明Stack中的元素必须是String类型
      Stack<String> list = new Stack<String>();
      // List接口中的通用方法不再列举
      // 把项压入堆栈顶部
      list.push("jiang");
      list.push("gu");
      list.push("jin");
      while (!list.isEmpty())
      {
         // 移除堆栈顶部的对象，并作为此函数的值返回该对象
         System.out.println(list.pop());
      }
   }
}