上一篇博客《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> 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> 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> list = new LinkedList<String>();
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 方法。
构造方法
方法摘要
返回值 | 方法名 | 说明 |
---|
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> list = new Stack<String>();
list.push("jiang");
list.push("gu");
list.push("jin");
while (!list.isEmpty())
{
System.out.println(list.pop());
}
}
}