java 集合之LinkedList
-
List 和 Deque 接口的双向链表实现。 实现所有可选的列表操作,并允许所有元素(包括空值)。
- 除了实现 List 接口外,LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。
- 实现 Deque 接口,为 add、poll 提供先进先出队列操作,以及其他堆栈和双端队列操作。
-
所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头或结尾遍历列表(从靠近指定索引的一端)。
-
请注意,此实现不是同步的。 如果多个线程并发访问一个链表,并且至少有一个线程在结构上修改了链表,则必须进行外部同步。 (结构修改是添加或删除一个或多个元素的任何操作;仅设置元素的值不是结构修改。)这一般通过对自然封装该列表的对象进行同步操作来完成。
- 如果不存在此类对象,则应使用 Collections.synchronizedList 方法“包装”该列表。为防止对列表的意外不同步访问, 最好在创建时完成:
List list = Collections.synchronizedList(new LinkedList(...));
- 如果不存在此类对象,则应使用 Collections.synchronizedList 方法“包装”该列表。为防止对列表的意外不同步访问, 最好在创建时完成:
-
此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的:在迭代器创建之后,如果从结构上对列表进行修改,除非通过迭代器自身的 remove 或 add 方法,其他任何时间任何方式的修改,迭代器都将抛出 ConcurrentModificationException。 因此,面对并发修改,迭代器快速而干净地失败,而不是冒着在未来不确定的时间出现任意、非确定性行为的风险。
-
请注意,迭代器的快速失败行为不能得到保证,一般而言,存在不同步的并发修改时,不可能作出任何硬性保证。 快速失败的迭代器会尽最大努力抛出 ConcurrentModificationException。 因此,编写一个依赖此异常来确保其正确性的程序是错误的:迭代器的快速失败行为应该仅用于检测错误。
-
LinkedList可以添加重复数据
构造方法
LinkedList()
构造一个空列表。
LinkedList(Collection<? extends E> c)
按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表。
方法
Modifier and Type | Method | Description |
---|---|---|
void | add (int index, E element) | 在此列表中的指定位置插入指定元素。 |
boolean | add (E e) | 将指定元素附加到此列表的末尾。 |
boolean | addAll (int index, Collection<? extends E> c) | 将指定 collection 中的所有元素从指定位置开始插入此列表。 |
boolean | addAll (Collection<? extends E> c) | 按照指定集合的迭代器返回的顺序,将指定集合中的所有元素追加到此列表的末尾。 |
void | addFirst (E e) | 将指定元素插入此列表的开头。 |
void | addLast (E e) | 将指定元素添加到此列表的结尾。 |
void | clear() | 从此列表中删除所有元素。 |
Object | clone() | 返回此 LinkedList 的浅表副本。 |
boolean | contains (Object o) | 如果此列表包含指定元素,则返回 true。 |
Iterator | descendingIterator() | 返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。 |
E | element() | 检索但不删除此列表的头部(第一个元素)。 |
E | get (int index) | 返回此列表中指定位置的元素。 |
E | getFirst() | 返回此列表中的第一个元素。 |
E | getLast() | 返回此列表中的最后一个元素。 |
int | indexOf (Object o) | 返回此列表中指定元素第一次出现的索引,如果此列表不包含该元素,则返回 -1。 |
int | lastIndexOf (Object o) | 返回此列表中指定元素最后一次出现的索引,如果此列表不包含该元素,则返回 -1。 |
ListIterator | 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() | 返回此列表中的元素数。 |
Spliterator | spliterator() | 在此列表中的元素上创建一个后期绑定和快速失败的 Spliterator。 |
Object[] | toArray() | 返回一个数组,该数组以适当的顺序(从第一个元素到最后一个元素)包含此列表中的所有元素。 |
T[] | toArray (T[] a) | 以适当的顺序(从第一个元素到最后一个元素)返回一个包含此列表中所有元素的数组; 返回数组的运行时类型是指定数组的类型。 |
- 从类 java.util.AbstractSequentialList 继承的方法
iterator
- 从类 java.util.AbstractList 继承的方法
equals, hashCode, listIterator, removeRange, subList
- 从类 java.util.AbstractCollection 继承的方法
containsAll, isEmpty, removeAll, retainAll, toString
- 从类 java.lang.Object 继承的方法
finalize, getClass, notify, notifyAll, wait, wait, wait
- 从接口 java.util.List 继承的方法
containsAll, equals, hashCode, isEmpty, iterator, listIterator, removeAll, retainAll, subList
- 从接口 java.util.Deque 继承的方法
iterator
LinkedList特有方法
增加
addFirst(E e) addLast(E e)
offer(E e) offerFirst(E e) offerLast(E e)
//创建一个LinkedList集合对象:
LinkedList<String> list = new LinkedList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("b");//LinkedList可以添加重复数据
System.out.println(list); //[a, b, c, b]
list.addFirst("jj");
list.addLast("hh");
System.out.println(list); //[jj, a, b, c, b, hh]
list.offer("kk");//添加元素在尾端
list.offerFirst("pp");
list.offerLast("rr");
删除
poll() pollFirst() pollLast()
:JDK1.6新出的方法,提高了代码的健壮性
removeFirst() removeLast()
System.out.println(list); //[pp, jj, a, b, c, b, hh, kk, rr]
System.out.println(list.poll()); //pp 删除头上的元素并且将元素输出
System.out.println(list.pollFirst()); //jj
System.out.println(list.pollLast()); //rr
System.out.println(list.removeFirst()); //a
System.out.println(list.removeLast()); //kk
修改
set (int index, E element)
System.out.println(list.set(3, "a")); //hh
System.out.println(list); //[b, c, b, a]
查看
element()
getFirst() getLast()
indexOf(Object o) lastIndexOf(Object o)
peek() peekFirst() peekLast()
System.out.println(list); //[b, c, b, a]
System.out.println(list.element()); //b
System.out.println(list.getFirst()); //b
System.out.println(list.getLast()); //a
System.out.println(list.indexOf("b")); //0
System.out.println(list.lastIndexOf("b")); //2
System.out.println(list.peek()); //b
System.out.println(list.peekFirst()); //b
System.out.println(list.peekLast()); //a
System.out.println(list); //[b, c, b, a]
遍历
System.out.println("-------普通for循环-------");
//普通for循环:
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + "\t");
}
System.out.println("\n-------增强for-------");
//增强for:
for (String s : list) {
System.out.print(s + "\t");
}
System.out.println("\n-------迭代器-------");
//迭代器:
Iterator<String> it = list.iterator();
while (it.hasNext()) {
System.out.print(it.next() + "\t");
}
System.out.println("\n-------强化迭代器-------");
//下面这种方式好,节省内存
for (Iterator<String> it2 = list.iterator(); it2.hasNext(); ) {
System.out.print(it2.next() + "\t");
}
listIterator
处理迭代器与list不能同时操作问题
public class Listiter {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("aa");
list.add("bb");
list.add("cc");
list.add("dd");
/* //在"cc"之后添加一个字符串"kk" 出错,原因:就是迭代器和list同时对集合进行操作:
Iterator<String> it0 = list.iterator();
while(it0.hasNext()){
if("cc".equals(it0.next())){
list.add("kk");
}
}*/
//解决办法:引入新的迭代器:ListIterator,迭代和添加操作都是靠ListIterator来完成的:
ListIterator<String> it = list.listIterator();
while(it.hasNext()){
if("cc".equals(it.next())){
it.add("kk");
}
}
System.out.println(it.hasNext()); //false,以当前指针位置为准
System.out.println(it.hasPrevious()); //true
//逆向遍历:
System.out.println("------逆向遍历------");
while(it.hasPrevious()){
System.out.print(it.previous() + "\t");
}
System.out.println(it.hasNext());//true
System.out.println(it.hasPrevious()); //false
System.out.println(list); //[aa, bb, cc, kk, dd]
}
}
相关源码
public class LinkedList<E>{
//E是一个泛型,具体的类型要在实例化的时候才会最终确定
transient int size = 0;//集合中元素的数量
private static class Node<E> {
//Node的内部类,节点类
E item;//当前元素
Node<E> next;//指向下一个元素地址
Node<E> prev;//上一个元素地址
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
transient Node<E> first;//链表的首节点
transient Node<E> last;//链表的尾节点
public LinkedList() {
//空构造器:
}
public boolean add(E e) {
//添加元素操作:
linkLast(e);
return true;
}
void linkLast(E e) {
//添加的元素e
final Node<E> l = last;//将链表中的last节点给l,如果是第一个元素,则l为null
//将元素封装为一个Node具体的对象:
final Node<E> newNode = new Node<>(l, e, null);
//将链表的last节点指向新的创建的对象:
last = newNode;
if (l == null)//如果添加的是第一个节点
first = newNode;//将链表的first节点指向为新节点
else//如果添加的不是第一个节点
l.next = newNode;//将l的下一个指向为新的节点
size++;//集合中元素数量加1操作
modCount++;
}
public int size() {
//获取集合中元素数量
return size;
}
public E get(int index) {
//通过索引得到元素:
checkElementIndex(index);//健壮性考虑
return node(index).item;
}
Node<E> node(int index) {
//如果index在链表的前半段,那么从前往后找
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
//如果index在链表的后半段,那么从后往前找
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
}