标签：java list 集合 linkedlist 线性表
LinkedList类是List接口的实现类，它是一个List集合，可以根据索引来随机访问集合元素。除此之外，LinkedList还实
现了Deque接口，因此它可以被当成双端队列来使用，也可以被当成“栈”来使用。LinkedList是基于链的线性表。
以下是官方对LinkedList类的说明：
List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口
外，LinkedList 类还为在列表的开头及结尾 get、remove 和insert 元素提供了统一的命名方法。这些操作允许将链接
此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。
所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头或结尾遍历列表（从靠近指定索引
的一端）。
注意，此实现不是同步的。如果多个线程同时访问一个链接列表，而其中至少一个线程从结构上修改了该列表，则
它必须 保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这
一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使
用Collections.synchronizedList方法来“包装”该列表。最好在创建时完成这一操作，以防止对列表进行意外的不同步访
问，如下所示：
List list = Collections.synchronizedList(new LinkedList(...));
此类的 iterator 和listIterator 方法返回的迭代器是快速失败 的：在迭代器创建之后，如果从结构上对列表进行修改，
除非通过迭代器自身的 remove 或add 方法，其他任何时间任何方式的修改，迭代器都将抛出
ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不冒将来不确定的时间任
意发生不确定行为的风险。
注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何硬性保证。快
速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的方式是错误的，
正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。
以下是LinkedList类的绝大部分方法：
public class Main {
public static void main(String[] args) {
LinkedList linkedList=new LinkedList();
/*
* boolean add(E e)
* 将指定元素添加到此列表的结尾。
*/
linkedList.add("A");
//输出：[A]
System.out.println(linkedList);
/*
* void add(int index, E element)
* 在此列表中指定的位置插入指定的元素。
*/
linkedList.add(1, "B");
//输出：[A, B]
System.out.println(linkedList);
/*
* boolean addAll(Collection<? extends E> c)
* 添加指定 collection 中的所有元素到此列表的结尾，
* 顺序是指定 collection 的迭代器返回这些元素的顺序。
*/
ArrayList arrayList=new ArrayList();
arrayList.add("C");
arrayList.add("D");
linkedList.addAll(arrayList);
//输出：[A, B, C, D]
System.out.println(linkedList);
/*
* boolean addAll(int index, Collection<? extends E> c)
* 将指定 collection 中的所有元素从指定位置开始插入此列表。
*/
ArrayList list=new ArrayList();
list.add("E");
list.add("F");
linkedList.addAll(4, list);
//输出：[A, B, C, D, E, F]
System.out.println(linkedList);
/*
* void addFirst(E e)
* 将指定元素插入此列表的开头。
*/
linkedList.addFirst("First");
//输出：[First, A, B, C, D, E, F]
System.out.println(linkedList);
/*
* void addLast(E e)
* 将指定元素添加到此列表的结尾。
*/
linkedList.addLast("Last");
//输出：[First, A, B, C, D, E, F, Last]
System.out.println(linkedList);
/*
* Object clone()
* 返回此 LinkedList 的浅表副本。
*/
LinkedList linkedListClone=(LinkedList)linkedList.clone();
linkedListClone.add("clone");
//输出：[First, A, B, C, D, E, F, Last, clone]
System.out.println(linkedListClone);
//输出：[First, A, B, C, D, E, F, Last]
System.out.println(linkedList);
/*
* boolean contains(Object o)
* 如果此列表包含指定元素，则返回 true。
*/
//输出：true
System.out.println(linkedList.contains("First"));
/*
* Iterator<E> descendingIterator()
* 返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
*/
Iterator iterator=linkedList.descendingIterator();
//输出：Last F E D C B A First
while(iterator.hasNext()){
System.out.print(iterator.next()+" ");
}
System.out.println();
/*
* E element()
* 获取但不移除此列表的头（第一个元素）。
*/
//输出;First
System.out.println(linkedList.element());
//输出：[First, A, B, C, D, E, F, Last]
System.out.println(linkedList);
/*
* E get(int index)
* 返回此列表中指定位置处的元素。
*/
//输出：A
System.out.println(linkedList.get(1));
/*
* E getFirst()
* 返回此列表的第一个元素。
*/
//输出：First
System.out.println(linkedList.getFirst());
/*
* E getLast()
* 返回此列表的最后一个元素。
*/
//输出：Last
System.out.println(linkedList.getLast());
/*
* int indexOf(Object o)
* 返回此列表中首次出现的指定元素的索引，
* 如果此列表中不包含该元素，则返回 -1。
*/
//输出：4
System.out.println(linkedList.indexOf("D"));
/*
* int lastIndexOf(Object o)
* 返回此列表中最后出现的指定元素的索引，
* 如果此列表中不包含该元素，则返回 -1。
*/
//输出：6
System.out.println(linkedList.lastIndexOf("F"));
/*
* ListIterator<E> listIterator(int index)
* 返回此列表中的元素的列表迭代器（按适当顺序），
* 从列表中指定位置开始。
*/
ListIterator listIterator=linkedList.listIterator(3);
//输出：C D E F Last
while(listIterator.hasNext()){
System.out.print(listIterator.next()+" ");
}
System.out.println();
/*
* boolean offer(E e)
* 将指定元素添加到此列表的末尾（最后一个元素）。
*/
linkedList.offer("offer");
//输出：[First, A, B, C, D, E, F, Last, offer]
System.out.println(linkedList);
/*
* boolean offerFirst(E e)
* 在此列表的开头插入指定的元素。
*/
linkedList.offerFirst("offerFirst");
//输出：[offerFirst, First, A, B, C, D, E, F, Last, offer]
System.out.println(linkedList);
/*
* boolean offerLast(E e)
* 在此列表末尾插入指定的元素。
*/
linkedList.offerLast("offerLast");
//输出：[offerFirst, First, A, B, C, D, E, F, Last, offer, offerLast]
System.out.println(linkedList);
/*
* E peek()
* 获取但不移除此列表的头（第一个元素）。
*/
//输出：offerFirst
System.out.println(linkedList.peek());
//输出：[offerFirst, First, A, B, C, D, E, F, Last, offer, offerLast]
System.out.println(linkedList);
/*
* E peekFirst()
* 获取但不移除此列表的第一个元素；
* 如果此列表为空，则返回 null。
*/
//输出：offerFirst
System.out.println(linkedList.peekFirst());
//输出：[offerFirst, First, A, B, C, D, E, F, Last, offer, offerLast]
System.out.println(linkedList);
/*
* E peekLast()
* 获取但不移除此列表的最后一个元素；如果此列表为空，
* 则返回 null。
*/
//输出：offerLast
System.out.println(linkedList.peekLast());
//输出：[offerFirst, First, A, B, C, D, E, F, Last, offer, offerLast]
System.out.println(linkedList);
/*
* E poll()
* 获取并移除此列表的头（第一个元素）
*/
//输出：offerFirst
System.out.println(linkedList.poll());
//输出：[First, A, B, C, D, E, F, Last, offer, offerLast]
System.out.println(linkedList);
/*
* E pollFirst()
* 获取并移除此列表的第一个元素；如果此列表为空，
* 则返回 null。
*/
//输出：First
System.out.println(linkedList.pollFirst());
//输出：[A, B, C, D, E, F, Last, offer, offerLast]
System.out.println(linkedList);
/*
* E pollLast()
* 获取并移除此列表的最后一个元素；如果此列表为空，
* 则返回 null。
*/
//输出：offerLast
System.out.println(linkedList.pollLast());
//输出：[A, B, C, D, E, F, Last, offer]
System.out.println(linkedList);
/*
* E pop()
* 从此列表所表示的堆栈处弹出一个元素。
*/
//输出：A
System.out.println(linkedList.pop());
//输出：[B, C, D, E, F, Last, offer]
System.out.println(linkedList);
/*
* void push(E e)
* 将元素推入此列表所表示的堆栈。
*/
linkedList.push("A");
//输出：[A, B, C, D, E, F, Last, offer]
System.out.println(linkedList);
/*
* E remove()
* 获取并移除此列表的头（第一个元素）。
*/
//输出：A
System.out.println(linkedList.remove());
//输出：[B, C, D, E, F, Last, offer]
System.out.println(linkedList);
/*
* E remove(int index)
* 移除此列表中指定位置处的元素。
*/
//输出：offer
System.out.println(linkedList.remove(6));
//输出：[B, C, D, E, F, Last]
System.out.println(linkedList);
/*
* boolean remove(Object o)
* 从此列表中移除首次出现的指定元素（如果存在）。
*/
linkedList.remove("Last");
//输出：[B, C, D, E, F]
System.out.println(linkedList);
/*
* E removeFirst()
* 移除并返回此列表的第一个元素。
*/
//输出：B
System.out.println(linkedList.removeFirst());
//输出：[C, D, E, F]
System.out.println(linkedList);
/*
* boolean removeFirstOccurrence(Object o)
* 从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
*/
linkedList.removeFirstOccurrence("D");
//输出：[C, E, F]
System.out.println(linkedList);
/*
* E removeLast()
* 移除并返回此列表的最后一个元素。
*/
//输出：F
System.out.println(linkedList.removeLast());
//输出：[C, E]
System.out.println(linkedList);
/*
* boolean removeLastOccurrence(Object o)
* 从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。
*/
linkedList.removeLastOccurrence("E");
//输出：[C]
System.out.println(linkedList);
/*
* E set(int index, E element)
* 将此列表中指定位置的元素替换为指定的元素。
*/
//输出：C
System.out.println(linkedList.set(0, "set"));
//输出：[set]
System.out.println(linkedList);
/*
* int size()
* 返回此列表的元素数。
*/
//输出：1
System.out.println(linkedList.size());
/*
* Object[] toArray()
* 返回以适当顺序（从第一个元素到最后一个元素）
* 包含此列表中所有元素的数组。
*/
//输出：[set]
System.out.println(Arrays.toString(linkedList.toArray()));
/*
* void clear()
* 从此列表中移除所有元素。
*/
linkedList.clear();
//输出：[]
System.out.println(linkedList);
}
}
标签：java list 集合 linkedlist 线性表
原文地址：http://blog.csdn.net/hai_qing_xu_kong/article/details/44134565
