LinkedList源码详解（基于jdk1.8.0_231）
1. LinkedList简介
- LinkedList数据结构为双链表, 继承了AbstractSequentialList 实现了List, Deque, Cloneable, java.io.Serializable接口;
- 允许所有元素为null;
- LinkedList多线程环境下,不是线程安全的,需要外部加锁或使用其他线程安全的链表替代或使用Collettions.synchronizedList(new LinkedList(...))包装;
- 与ArrayList一样,Iterator,listIteratot两种迭代器都有fail-fast机制,提醒业务开发程序员,目前可能是多线程环境,使用LinkedList不安全;
- 与ArrayList不同,LinkedList由于是双端链表,一般地,LinkedList头尾插入和删除时间复杂为O(1),查找的时间复杂度为O(n),而ArrayList的头插入和删除时间复杂度为O(n),查找时间为O(1),所以在大量删除插入操作中推荐使用LinkedList,大量查找操作中推荐使用ArrayList.
- 相比于ArrayList,LinkedList在并行操作时,会有一些操作要求,ArrayList很容易并行.
- LinkedList没有所谓的扩容机制,不考虑虚拟内存情况下,内存余量多大,他可扩多大;
- 根据“实现了啥接口，就必须提供啥服务”原则，LinkedList实现Deque接口，则LinkedList一定可以做双端队列，当然也可以当普通队列啦。
- LinkedList实现了大量相似的方法，如增加节点 add addLast offer offerLast 这些方法都是将节点插入LinkedList尾部，我习惯于根据LinkedList实际场合的扮演的数据结构，使用对应的方法，或根据具体情况需要啥返回值采用对应的API。具体来讲，当LinkedList当单向链表，我习惯使用add添加元素，当linkedList当双向链表，我习惯使用addLast addFist添加元素，当LinkedList当单向队列，我习惯使用offer方法，当LinkedList当双向队列，我习惯使用offerLast offerFirst方法。在阅读完源码后，会给出相关的总结。“是啥数据结构，提供啥语义接口”这样我们的代码可读性才比较好。
2. LinkedList逻辑内存模型
根据LinkedList源码,我们称包含pre item next三个域的结构为一个Node.
Node类
private static class Node<E> {
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;
}
}
3. LinkedList UML简图
4. LinkedList API简介
自定义的字段
transient int size = 0;
transient Node<E> first; //头指针（对头结点的引用）
transient Node<E> last; //尾指针（对尾结点的引用）
private static final long serialVersionUID = 876323262645176354L;
直接继承的字段
protected transient int modCount = 0; //继承自AbstractList
构造函数
public LinkedList()
public LinkedList(Collection<? extends E> c)
override或新增的API(public 方法)
-----------------增加节点的方法---------------------
void addFirst(E e) //头插法，插入的新元素为头结点
void addLast(E e) //尾插法，插入的新元素为尾节点
boolean add(E e) //尾插法，插入的新元素为尾节点
void add(int index, E element)
boolean addAll(Collection<? extends E> c)
boolean addAll(int index,Collection<? extends E> c)
-----------------删除节点的方法---------------------
E remove(int index)
E removeFirst() //删除头结点
E removeLast() //删除尾节点
boolean remove(Object o) //按元素删除
boolean removeFirstOccurrence（Object o）
boolean removeLastOccurrence(Object o)
void clean()
----------------查找节点的方法----------------------
int indexOf(Object o)
int lastIndexOf(Object o)
E getFirst() //查头结点
E getLast() //查尾节点
E get(int index)
boolean contains(Object o)
int size()
----------------修改节点的方法----------------------
E set(int index,E element)
----------------LinkedList作为栈的方法--------------
void push(E e)
E pop()
---------------LinkedList作为双端队列的方法---------
boolean offerFirst(E e)
boolean offerLast(E e)
E pollFirst()
E pollLast()
E peekFirst()
E peekLast()
---------------- 作为单向队列的方法-----------------
boolean offer(E e) //等价于add
E poll()
E remove() //遇到队头为null,返回null
E peek()
E element() // 遇到对头为null,抛异常
---------------迭代器------------------------------
ListIterator<E> listIterator(int index)
Iterator<E> descendingIterator()
----------------LinkedList数组化------------------
Object[] toArray()
<T> T[] toArray(T[] a)
----------------其他方法--------------------------
Object clone() //LinkedList浅拷贝
Spliterator<E> spliterator()
直接继承超类或来自实现接口的default方法
public int hashCode() //继承自AbstractList
public boolean equals(Object o) //继承自AbstractList
public List<E> subList(int fromIndex, int toIndex)//继承自AbstractList
default Stream<E> stream()//来自Colletion接口
default Stream<E> parallelStream() //来自Colletion接口
default boolean removeIf(Predicate<? super E> filter) //来自接口Collection
public boolean isEmpty() //继承自AbstractCollection
public boolean retainAll(Collection<?> c) //继承自AbstractColletion
public Iterator<E> iterator() //继承自AbstractSequentialList
default void sort(Comparator<? super E> c) //来自List接口
default void replaceAll(UnaryOperator<E> operator) //来自List接口
default void replaceAll(UnaryOperator<E> operator) //来自List接口
LinkedList类的包方法
void linkLast(E e)
void linkBefore(E e,Node<E> succ)
E unlink(Node<E> x)
Node<E> node(int index)
LinkedList类的private方法
void linkFist(E e)
E unlinkFirst(Node<E> f)
E unlinkLast(Node<E> l)
boolean isElementIndex(int index)
boolean isPositionIndex(int index)
String outOfBounsMsg(int index)
void checkElementIndex(int index)
void checkPositionIndex(int index)
LinkedList<E> superClone()
void writeObject(java.io.ObjectOutputStream s)
void readObject(java.io.ObjectInputStream s)
5. LinkedList源码（基于jdk1.8.0_231）
package java.util;
import java.util.function.Consumer;
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
transient int size = 0; //双端链表的实际含元素
transient Node<E> first; //头结点的引用
transient Node<E> last; //尾结点的引用
//构造一个空的LinkedList
public LinkedList() {
}
//构造一个LinkedList包含具体的集合,如果集合为null,会抛出NullPointerException
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
//头插法,即每次添加的元素都为第一个元素,私有的类方法
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f); //
first = newNode; //更新first指向newNode,即newNode为头结点了
if (f == null) //f为空,即初始的链表为空,让first,last同时指向newNode
last = newNode;
else
f.prev = newNode; //否则f不为空，让f.pre指向newNode
size++;
modCount++;
}
//尾插法,即每次添加元素都添加在链表的最后一个后面,包方法
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode; //更新最后一个节点为newNode
if (l == null) //如果l为空,说明链表是空链表
first = newNode; //让first，last同时指向newNode
else
l.next = newNode; //否则让l.next指向newNode
size++;
modCount++;
}
//按元素插入,在节点succ前插入e节点,succ不能为null节点,注意null节点与节点的item=null不是一个概念,可以在item=null前插入新节点哦
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
final Node<E> pred = succ.prev;
final Node<E> newNode = new Node<>(pred, e, succ);
succ.prev = newNode;
if (pred == null)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}
//删除头节点frist,在将LinkedList作为队列,双端队列,弹出头节点时使用,private方法被poll removeFirst pollFirst等public方法调用
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item;
final Node<E> next = f.next;
f.item = null;
f.next = null; // help GC
first = next;
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
//删除尾节点last,在将LinkedList作为队列,双端队列,弹出尾节点时使用或栈式,弹出栈顶,private方法被removeLast pollLast等public方法调用
private E unlinkLast(Node<E> l) {
// assert l == last && l != null;
final E element = l.item;
final Node<E> prev = l.prev;
l.item = null;
l.prev = null; // help GC
last = prev;
if (prev == null)
first = null;
else
prev.next = null;
size--;
modCount++;
return element;
}
//把节点x前后断开,把x节点从链表中移除
E unlink(Node<E> x) {
// assert x != null;
final E element = x.item;
final Node<E> next = x.next; //x节点前节点
final Node<E> prev = x.prev; //x节点后节点
if (prev == null) { //前节点为空,说明x节点就是first指向的节点,就是第一个节点
first = next;
} else {
prev.next = next; //x前节点不为空, 让前节点next域指向next节点
x.prev = null; //将x节点prev域置空
}
if (next == null) { //x后节点为空,说明x节点就是last指向的节点,就是最后一个节点
last = prev;
} else {
next.prev = prev; //x后节点prev域指向x前节点
x.next = null; //x节点的next域置空
}
x.item = null;
size--;
modCount++;
return element;
}
//返回第一个节点item域
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
//返回最后一个节点item域
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
//remove第一个节点
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
//remove最后一个节点
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
//头插法加入一个节点,每次节点都成为第一个节点,first更新指向新加入的节点
public void addFirst(E e) {
linkFirst(e);
}
//尾插法加入一个节点,每次节点都成为最后一个节点,last更新指向新加入的节点
public void addLast(E e) {
linkLast(e);
}
//检查链表是否至少存在一个对象o,若存在,返回true,时间复杂度为O(n)
public boolean contains(Object o) {
return indexOf(o) != -1; //indexOf遍历链表,得出o的位置,若o不在链表中,返回-1,否则返回位置索引
}
//返回链表种总共有多少个元素
public int size() {
return size;
}
//尾插法,加入新元素,时间复杂度为O(1),此方法等价于addLast
public boolean add(E e) {
linkLast(e);
return true;
}
//remove链表中顺序第一次出现的指定的对象o,移除成功会返回true,否则返回false
public boolean remove(Object o) {
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
//从链表尾部新加入一个集合,c为null,会抛NullPointerException
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
//从具体位置新加入一个新集合
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
Node<E> pred, succ;
if (index == size) {
succ = null;
pred = last;
} else {
succ = node(index);
pred = succ.prev;
}
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
//清空链表
public void clear() {
// Clearing all of the links between nodes is "unnecessary", but:
// - helps a generational GC if the discarded nodes inhabit
// more than one generation
// - is sure to free memory even if there is a reachable Iterator
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null;
size = 0;
modCount++;
}
//根据位置,返回位置上的节点item域,其时间复杂度为O(n),千万不要再迭代for循环中用来取元素,这可是线上生产级别的重大事故,炒鱿鱼丢饭碗级别的事故
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
//将index位置的元素替换为element,并且返回原节点的item域,同get一样,千万不要在for中迭代中使用set
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
//按位置插入,在index中插入elemet,index位置有元素的话,element就插在其前
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
//按位置删除,删除第index位置的节点，返回删除节点的item域
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
//检查index在不在合理的链表范围，如果size在[0,size)返回true,否则返回false
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
//检查index的范围，在add操作情况下，index=size也是合理的
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
//越界异常信息提示
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size;
}
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//返回index位置的节点，其中这里做个优化，如果index小于size的一半，从first指向的节点（头节点）往后找，如果index大于size一半，从last指向的节点（尾接点）从后往前找
Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
// Search Operations
//从头结点前往后，返回对象o在链表中首次出现的位置
public int indexOf(Object o) {
int index = 0;
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}
////从尾结点开始，从后往前，返回对象o在链表中首次出现的位置
public int lastIndexOf(Object o) {
int index = size;
if (o == null) {
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (x.item == null)
return index;
}
} else {
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (o.equals(x.item))
return index;
}
}
return -1;
}
// Queue operations.
//peek是返回头结点的item域，如果头结点为null,则返回null
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
//返回头结点的item域，但是头结点=null时，会抛NoSuchElementException
public E element() {
return getFirst();
}
//返回头结点，且删除头结点，如果头结点=null,也返回null
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
//返回头结点，且删除头结点，如果头结点=null,会抛出NoSuchElementException
public E remove() {
return removeFirst();
}
//加入一个元素到链表尾部
public boolean offer(E e) {
return add(e);
}
// Deque operations 因为LinkedList实现了Deque接口，必然需要提供双端队列该有“服务”，可前后入队和出队
//从头入队
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
//从尾入队
public boolean offerLast(E e) {
addLast(e);
return true;
}
//返回头节点item域，头节点=null 也返回，不抛异常
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
//返回尾节点，尾节点=null,页返回，不抛异常
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
//返回并删除头节点，头结点=null,也返回，不抛异常
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
//返回并删除尾节点，尾结点=null,也返回，不抛异常
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
//下面push pop 将LinkedList作为栈，链表头始终作为栈顶，
//将LinkedList作为栈，头作为栈顶，压入一个元素入栈
public void push(E e) {
addFirst(e);
}
//将LinkedList作为栈，头作为栈顶，将一个个元素弹出栈
public E pop() {
return removeFirst();
}
//从头结点往后，remove链表第一次出现的对象o,remove成功返回true,否则返回false
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
//从尾结点往后，remove链表第一次出现的对象o,remove成功返回true,否则返回false
public boolean removeLastOccurrence(Object o) {
if (o == null) {
for (Node<E> x = last; x != null; x = x.prev) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = last; x != null; x = x.prev) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
//listIterator是双端迭代器，即可以从前也可以往后，也可以从特定位置开始迭代，迭代过程运行 fail-fast机制，通过迭代器的增删本质上就是对原链表的操作，
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned;
private Node<E> next;
private int nextIndex;
private int expectedModCount = modCount;
ListItr(int index) {
// assert isPositionIndex(index);
next = (index == size) ? null : node(index);
nextIndex = index;
}
public boolean hasNext() {
return nextIndex < size;
}
public E next() {
checkForComodification();
if (!hasNext())
throw new NoSuchElementException();
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.item;
}
public boolean hasPrevious() {
return nextIndex > 0;
}
public E previous() {
checkForComodification();
if (!hasPrevious())
throw new NoSuchElementException();
lastReturned = next = (next == null) ? last : next.prev;
nextIndex--;
return lastReturned.item;
}
public int nextIndex() {
return nextIndex;
}
public int previousIndex() {
return nextIndex - 1;
}
public void remove() {
checkForComodification();
if (lastReturned == null)
throw new IllegalStateException();
Node<E> lastNext = lastReturned.next;
unlink(lastReturned);
if (next == lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = null;
expectedModCount++;
}
public void set(E e) {
if (lastReturned == null)
throw new IllegalStateException();
checkForComodification();
lastReturned.item = e;
}
public void add(E e) {
checkForComodification();
lastReturned = null;
if (next == null)
linkLast(e);
else
linkBefore(e, next);
nextIndex++;
expectedModCount++;
}
public void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (modCount == expectedModCount && nextIndex < size) {
action.accept(next.item);
lastReturned = next;
next = next.next;
nextIndex++;
}
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
//每个节点的数据结构
private static class Node<E> {
E item; //item域
Node<E> next; //next域
Node<E> prev; //prev域
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
/**
* @since 1.6
*/
//从尾结点开始往前遍历节点
public Iterator<E> descendingIterator() {
return new DescendingIterator();
}
/**
* Adapter to provide descending iterators via ListItr.previous
*/
private class DescendingIterator implements Iterator<E> {
private final ListItr itr = new ListItr(size());
public boolean hasNext() {
return itr.hasPrevious();
}
public E next() {
return itr.previous();
}
public void remove() {
itr.remove();
}
}
@SuppressWarnings("unchecked")
//浅拷贝LinkedList
private LinkedList<E> superClone() {
try {
return (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
//返回LinkedList实例的一个浅拷贝，言下之意为：item域如果为引用类型，拷贝的只是指向内容的引用，而不是内存内容，若item是基本类型，可以认为就是深拷贝了
public Object clone() {
LinkedList<E> clone = superClone();
// Put clone into "virgin" state
clone.first = clone.last = null;
clone.size = 0;
clone.modCount = 0;
// Initialize clone with our elements
for (Node<E> x = first; x != null; x = x.next)
clone.add(x.item);
return clone;
}
//
public Object[] toArray() {
Object[] result = new Object[size];
int i = 0;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
return result;
}
//
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
int i = 0;
Object[] result = a;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
if (a.length > size)
a[size] = null;
return a;
}
private static final long serialVersionUID = 876323262645176354L;
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// Write out size
s.writeInt(size);
// Write out all elements in the proper order.
for (Node<E> x = first; x != null; x = x.next)
s.writeObject(x.item);
}
@SuppressWarnings("unchecked")
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// Read in size
int size = s.readInt();
// Read in all elements in the proper order.
for (int i = 0; i < size; i++)
linkLast((E)s.readObject());
}
@Override
public Spliterator<E> spliterator() {
return new LLSpliterator<E>(this, -1, 0);
}
/** A customized variant of Spliterators.IteratorSpliterator */
static final class LLSpliterator<E> implements Spliterator<E> {
static final int BATCH_UNIT = 1 << 10; // batch array size increment
static final int MAX_BATCH = 1 << 25; // max batch array size;
final LinkedList<E> list; // null OK unless traversed
Node<E> current; // current node; null until initialized
int est; // size estimate; -1 until first needed
int expectedModCount; // initialized when est set
int batch; // batch size for splits
LLSpliterator(LinkedList<E> list, int est, int expectedModCount) {
this.list = list;
this.est = est;
this.expectedModCount = expectedModCount;
}
final int getEst() {
int s; // force initialization
final LinkedList<E> lst;
if ((s = est) < 0) {
if ((lst = list) == null)
s = est = 0;
else {
expectedModCount = lst.modCount;
current = lst.first;
s = est = lst.size;
}
}
return s;
}
public long estimateSize() { return (long) getEst(); }
public Spliterator<E> trySplit() {
Node<E> p;
int s = getEst();
if (s > 1 && (p = current) != null) {
int n = batch + BATCH_UNIT;
if (n > s)
n = s;
if (n > MAX_BATCH)
n = MAX_BATCH;
Object[] a = new Object[n];
int j = 0;
do { a[j++] = p.item; } while ((p = p.next) != null && j < n);
current = p;
batch = j;
est = s - j;
return Spliterators.spliterator(a, 0, j, Spliterator.ORDERED);
}
return null;
}
public void forEachRemaining(Consumer<? super E> action) {
Node<E> p; int n;
if (action == null) throw new NullPointerException();
if ((n = getEst()) > 0 && (p = current) != null) {
current = null;
est = 0;
do {
E e = p.item;
p = p.next;
action.accept(e);
} while (p != null && --n > 0);
}
if (list.modCount != expectedModCount)
throw new ConcurrentModificationException();
}
public boolean tryAdvance(Consumer<? super E> action) {
Node<E> p;
if (action == null) throw new NullPointerException();
if (getEst() > 0 && (p = current) != null) {
--est;
E e = p.item;
current = p.next;
action.accept(e);
if (list.modCount != expectedModCount)
throw new ConcurrentModificationException();
return true;
}
return false;
}
public int characteristics() {
return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
}
}
}
API总结(一)
LinkedList由于数据结构的灵活性，设计了大量API,一些增删改查的API功能很相似。这里我们仅仅讨论public方法，下面给出对比：
- 增加节点的API
-----------------------------------------双向链表中的增加节点方法------------------------------------------------------------
public void addFirst(E e) //增加节点成为头节点，头插法，函数内部调用私有方法linkFirst(E e) 完成头插
public void addLast(E e) //增加节点称为尾节点，尾插法，函数内部调用私有方法linkLast(E e) 完成尾插
----------------------------------------单向链表中增加节点的方法-------------------------------------------------------------
public boolean add(E e) //尾插法，增加一个新结点，返回true,函数内部调用私有方法linkLast(E e)完成尾插
public void add(int index, E element) //在指定位置新增一个新节点，只适用LinkedLinked为单双向链表的，不符合作为队列，栈
----------------------------------------addAll方法用在单双链表中都可---------------------------------------------------------
public boolean addAll(Collection<? extends E> c) // 加入一个集合的元素，LinkedList作为单向链表，双向链表，单向队列，双向队列使用此方法都合适，作为栈的时候，不合适
public boolean addAll(int index, Collection<? extends E> c) //从指定位置加入一个集合的元素，LinkedList作为单向链表，双向链表，单向队列，双向队列使用此方法都合适，作为栈的时候，不合适
-----------------------------------------单向队列中增加节点的方法---------------------------------------------------------
public boolean offer(E e) //等价于add(E e)方法,offer内部也是调用add方法的,实现尾插
-----------------------------------------双向队列中增加节点的方法---------------------------------------------------------
public boolean offerFirst(E e) //offerFist函数内部调用addFirst(E e),始终返回true,完成头插,等价于addFirst
public boolean offerLast(E e) // offerLast函数内部调用addLast(E e),始终返回true,完成尾插,等价于addFirst
----------------------------------------栈中增加节点的方法---------------------------------------------------------------
public void push(E e) //将元素压入栈顶,LinkedList始终将头节点作为栈顶,push函数内部调用addFist函数完成操作,等价于addFist函数
- 删除节点的API
public E removeFirst() // 移除头结点，如果头节点为null,抛出NoSuchElementEXception,函数内部调用私有方法unlinkFirst(Node<E> f)完成头移除
public E removeLast() // 移除尾结点，如果尾节点为null,抛出NoSuchElementEXception，函数内部调用私用方法unlinkLast(Node<E> l)完成尾移除
public boolean remove(Object o) // 移除指定的节点o,节点o可以为null,若节点o存在在链表中，移除成果，返回true,否则返回false
public E remove(int index) //移除指定位置的元素，会检查index的范围[0,size)
public void clear() //清空LinkedList
-------------------------------------LinkedList作为单向队列时的删除方法-----------------------------------------------------------------
public E poll() //检索和删除对头节点,若对头为空(即队列为空),返回null,不为空,返回头节点的item域,poll函数内部调用私有unlinkFirst(Node<E> f)方法
public E remove() // 等价于removeFist函数,移除对头节点,如果头节点为null,抛出NoSuchElementEXception
-----------------------------------------双向队列中删除节点的方法-------------------------------------------------------------
public E pollFirst() //移除双端队列的队头节点,若队头节点为null,返回null,若不为空,移除对头,返回对头节点的item域
public E pollLast() //移除双端队列的队尾节点,若队尾节点为null,返回null,若不为空,移除对尾,返回对尾节点的item域
----------------------------------------栈中删除节点的方法---------------------------------------------------------------
public E pop() //弹出栈顶的元素,函数内部调用removeFirst()完成操作,等价于removeFirst
- 查询节点的API
-----------------------------------------单双链表中的查询节点方法------------------------------------------------------------
public E getFirst() // 得到头结点的item域，如果头结点为null,抛出NoSuchElementException
public E getLast() // 得到尾结点的item域，如果尾结点为null,抛出NoSuchElementException
public E get(int index) //得到指定index位置的元素，会检查index的范围[0,size)
public int indexOf(Object o) //顺序(从头结点往尾节点)查找节点o第一次出现在LinkedList中的位置
public int lastIndexOf(Object o) //逆序(从尾结点往头结点)查找节点o第一次出现在LinkedList中的位置
----------------------------------------单项队列中查询节点的方法-------------------------------------------------------------
public E peek() //返回队列的第一个节点,如队列为空,返回null,队列不为空,返回对头节点的item域,peek函数只负责检索,不会删除对头节点
public E element() //返回队列的第一个节点,如队列为空,抛出NoSuchElementException,函数内部调用getFist()函数,两者是等价的.element函数只负责检索,不会删除对头节点
-----------------------------------------双向队列中查询节点的方法---------------------------------------------------------
public E peekFirst() // 返回双端队列的队头,如果对头为null,返回null,如果队头不为空,返回队头节点的item域
public E peekLast() // 返回双端队列的队尾,如果对尾为null,返回null,如果队尾不为空,返回队尾节点的item域
- 更新节点的API
public E set(int index, E element) //将index位置的元素更新为element
6. LinkedList示例
作为双向链表使用
public class LinkedListTest {
public static void main(String[] args) {
List<Integer> arr = new Random(32)
.ints(0,1000).boxed().limit(20).collect(Collectors.toList());
System.out.println(arr);
/**
* 创建
*/
LinkedList<Integer> myLinkedList = new LinkedList<>(arr);
/**
* 作为双端列表 getFirst getLast removeFirst removeLast addFirst addLast set removeIf replaceAll
* indexOf lastIndexOf
*/
System.out.println(myLinkedList.getFirst());
System.out.println(myLinkedList.getLast());
myLinkedList.removeFirst();
myLinkedList.removeLast();
System.out.println(myLinkedList);
myLinkedList.addFirst(377); //头插
myLinkedList.addLast(644); //尾插
System.out.println(myLinkedList);
myLinkedList.set(myLinkedList.size() - 1,-1);
System.out.println(myLinkedList.get(myLinkedList.size()-1));
System.out.println(myLinkedList);
System.out.println(myLinkedList.set(myLinkedList.size()-1, 644));// 注意 get set 本身操作都是O(n)
System.out.println(myLinkedList);
myLinkedList.addAll(Arrays.asList(-1,-2,-3,-4));
System.out.println(myLinkedList);
myLinkedList.removeIf(x->x<=0);
System.out.println(myLinkedList);
myLinkedList.addAll(Arrays.asList(0,0,0,0));
System.out.println(myLinkedList);
myLinkedList.replaceAll(x -> {
if(x == 0) x =100;
return x;
});
System.out.println(myLinkedList);
myLinkedList.removeAll(Arrays.asList(100));
System.out.println(myLinkedList);
System.out.println(myLinkedList.indexOf(122));
System.out.println(myLinkedList.lastIndexOf(122));
/**
* 迭代操作
*/
System.out.println(myLinkedList);
ListIterator<Integer> listIterator = myLinkedList.listIterator();
listIterator.forEachRemaining(x-> System.out.print(x+","));
System.out.println();
myLinkedList.forEach(x-> System.out.print(x+","));
System.out.println();
Iterator<Integer> iterator = myLinkedList.descendingIterator();
iterator.forEachRemaining(x-> System.out.print(x+","));
System.out.println();
Iterator<Integer> ite = myLinkedList.iterator();
ite.forEachRemaining(x-> System.out.print(x+","));
System.out.println();
int size = myLinkedList.size();
for(int i =0;i<size;i++){
System.out.print(myLinkedList.get(i)+","); //不要这样做，这个时间复杂度是O(n*n)
}
}
}
- 结果
[377, 331, 985, 41, 239, 122, 200, 791, 256, 734, 937, 80, 806, 346, 676, 748, 406, 92, 611, 644]
377
644
[331, 985, 41, 239, 122, 200, 791, 256, 734, 937, 80, 806, 346, 676, 748, 406, 92, 611]
[377, 331, 985, 41, 239, 122, 200, 791, 256, 734, 937, 80, 806, 346, 676, 748, 406, 92, 611, 644]
-1
[377, 331, 985, 41, 239, 122, 200, 791, 256, 734, 937, 80, 806, 346, 676, 748, 406, 92, 611, -1]
-1
[377, 331, 985, 41, 239, 122, 200, 791, 256, 734, 937, 80, 806, 346, 676, 748, 406, 92, 611, 644]
[377, 331, 985, 41, 239, 122, 200, 791, 256, 734, 937, 80, 806, 346, 676, 748, 406, 92, 611, 644, -1, -2, -3, -4]
[377, 331, 985, 41, 239, 122, 200, 791, 256, 734, 937, 80, 806, 346, 676, 748, 406, 92, 611, 644]
[377, 331, 985, 41, 239, 122, 200, 791, 256, 734, 937, 80, 806, 346, 676, 748, 406, 92, 611, 644, 0, 0, 0, 0]
[377, 331, 985, 41, 239, 122, 200, 791, 256, 734, 937, 80, 806, 346, 676, 748, 406, 92, 611, 644, 100, 100, 100, 100]
[377, 331, 985, 41, 239, 122, 200, 791, 256, 734, 937, 80, 806, 346, 676, 748, 406, 92, 611, 644]
5
5
[377, 331, 985, 41, 239, 122, 200, 791, 256, 734, 937, 80, 806, 346, 676, 748, 406, 92, 611, 644]
377,331,985,41,239,122,200,791,256,734,937,80,806,346,676,748,406,92,611,644,
377,331,985,41,239,122,200,791,256,734,937,80,806,346,676,748,406,92,611,644,
644,611,92,406,748,676,346,806,80,937,734,256,791,200,122,239,41,985,331,377,
377,331,985,41,239,122,200,791,256,734,937,80,806,346,676,748,406,92,611,644,
377,331,985,41,239,122,200,791,256,734,937,80,806,346,676,748,406,92,611,644,
作为栈使用
练习使用push pop函数,LinkedList作为栈，头节点始终为栈顶
public class MyStack<E> extends LinkedList<E> {
public void push(E e){
super.push(e);
}
public E pop(){
E e = super.pop();
return e;
}
public static void main(String[] args) {
MyStack<String> stack = new MyStack<>();
stack.push("hello");
stack.push("world");
System.out.println(stack.toString());
String s = stack.pop();
System.out.println(s);
System.out.println(stack);
}
}
- 结果
[world, hello]
world
[hello]
作为双端队列使用
public class MyQueue<E> extends LinkedList<E> {
public MyQueue(Collection<? extends E> c) {
super.addAll(c);
}
/**
* 对头的增删查
*
*/
//peekFirst是返回头结点的item域，如果头结点为null,则返回null
@Override
public E peekFirst() {
return super.peekFirst();
}
//从队头入队
@Override
public boolean offerFirst(E e) {
return super.offerFirst(e);
}
//返回头结点，且删除头结点，如果头结点=null,也返回null
@Override
public E pollFirst() {
return super.pollFirst();
}
/**
* 队尾的增删查
*/
@Override
public boolean offerLast(E e) {
return super.offerLast(e);
}
@Override
public E removeLast() {
return super.removeLast();
}
@Override
public E peekLast() {
return super.peekLast();
}
public static void main(String[] args) {
MyQueue<Integer> myQueue = new MyQueue<>(Arrays.asList(20,13,15));
System.out.println(myQueue);
myQueue.offerLast(100);
System.out.println(myQueue); //加入队尾
myQueue.offerFirst(1);
System.out.println(myQueue); //加入队头
System.out.println(myQueue.peekFirst());
System.out.println(myQueue.peekLast());
myQueue.offerLast(null);
System.out.println(myQueue.peekLast()); //返回null
myQueue.pollFirst();
System.out.println(myQueue); //从对头出队
myQueue.pollLast();
System.out.println(myQueue);//从队尾出队
}
}
- 结果
[20, 13, 15]
[20, 13, 15, 100]
[1, 20, 13, 15, 100]
1
100
null
[20, 13, 15, 100, null]
[20, 13, 15, 100]
7. 面试session
-
谈谈你对LinkeList的认识?
LinkedList数据结构是双端链表，由于其数据结构的灵活性，LinkedList可以做单向链表，双向链表,单向队列，双端队列，栈(头结点所在位置始终为栈顶)。针对不同的数据结构,LinkedList给出了操作API.
当LinkedList做单向链表时，我习惯使用add方法
当LinkedList做双端链表时，我习惯使用getFirst getLast removeFirst removeLast addFirst addLast方法
而 get set addALL 这些方法一般,在单双向链表中,我都会使用.
当LinkedList做单向队列时,我习惯使用 offer remove() poll peek element方法,其中peek element都是返回队头,当peek遇到空队头时,return null,而element抛异常;
当做双端队列时，我习惯使用peekFirst peekLast offerFirst offerLast pollFirst pollLast
当做栈时，我习惯使用pop push方法
一般地，peek返回值，不会删除；offer一般等价add;peek,poll在遇到null都会返回null,不会抛异常。 -
LinkedList和ArrayList的异同和使用场景?
简单来讲，大量的删除 增加 适合LinkedList,大量的随机访问适合ArrayList.特别低，大量在头部的增加删除操作，特别适合LinkedList,大量中间位置的查找适合ArrayList. -
LinkedList可以模拟哪些数据结构?
单向链表 双端链表 栈 队列 双端队列 -
LinkedList有几种迭代方式？
forEach listIterator（） iterator（） descendingIterator()
