LinkedList源码分析

成员变量

private transient Entry<E> header = new Entry<E>(null, null, null);

链表头元素

private transient int size = 0;

链表大小

构造方法

public LinkedList() {
		header.next = header.previous = header;
	}

无参构造。初始化链表头，将其next、previoous都指向其自身。

public LinkedList(Collection<? extends E> c) {
		this();
		addAll(c);
	}

该构造首先调用无参构造，然后将Collection中的元素加入到集合中。

方法

getFirst

public E getFirst() {
		if (size == 0)
			throw new NoSuchElementException();

		return header.next.element;
	}

返回链表中的第一个元素

getLast

public E getLast() {
		if (size == 0)
			throw new NoSuchElementException();

		return header.previous.element;
	}

返回链表中最后一个元素，由于其内部实现是双向链表，故直接调用header.previous.element即可。

removeFirst

public E removeFirst() {
		return remove(header.next);
	}

删除链表中的第一个元素，并返回其值，具体实现参见remove方法

removeLast

public E removeLast() {
		return remove(header.previous);
	}

删除链表中最后一个元素，并返回其值

addFirst

public void addFirst(E e) {
		addBefore(e, header.next);
	}

在链表头部插入一个元素

addLast

public void addLast(E e) {
		addBefore(e, header);
	}

在链表添加尾部插入一个元素

contains

public boolean contains(Object o) {
		return indexOf(o) != -1;
	}

检查是否包含指定元素

size

public int size() {
		return size;
	}

返回链表中元素的个数

add

public boolean add(E e) {
		addBefore(e, header);
		return true;
	}

在链表尾部加入一个元素

public void add(int index, E element) {
		addBefore(element, (index == size ? header : entry(index)));
	}

在某个位置加入元素

remove

public boolean remove(Object o) {
		if (o == null) {
			for (Entry<E> e = header.next; e != header; e = e.next) {
				if (e.element == null) {
					remove(e);
					return true;
				}
			}
		} else {
			for (Entry<E> e = header.next; e != header; e = e.next) {
				if (o.equals(e.element)) {
					remove(e);
					return true;
				}
			}
		}
		return false;
	}

删除某个元素，首先判断元素是否为null，然后进行相关的查找。

public E remove(int index) {
		return remove(entry(index));
	}

删除某一位置的元素

addAll

public boolean addAll(Collection<? extends E> c) {
		return addAll(size, c);
	}

将集合添加到链表的尾部

public boolean addAll(int index, Collection<? extends E> c) {
		if (index < 0 || index > size) //边界范围校验
			throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
					+ size);
		Object[] a = c.toArray(); //将集合转化成数组
		int numNew = a.length; //数组的长度
		if (numNew == 0)
			return false; //空集合则不用添加
		modCount++;  //结构变动变量自增

		Entry<E> successor = (index == size ? header : entry(index)); //确定集合元素添加到哪个元素之前，记为E
		Entry<E> predecessor = successor.previous; //保存E的前一个元素
		for (int i = 0; i < numNew; i++) { //循环要加入到链表的集合，
			Entry<E> e = new Entry<E>((E) a[i], successor, predecessor); //构建元素并将其next和previous分别指向E、E.previous。
			predecessor.next = e; //将E.previous的next指向新节点，这样新节点就会插入到链表中。仔细考虑此处并没有立即将successor的previous指向新节点，而是在整个循环结束之后才处理。
			predecessor = e; //将新构建的元素赋值给predecessor，即E.previous为新插入的节点，如此反复最终将这些集合元素添加到链表中
		}
		successor.previous = predecessor; //修复E的previous指向

		size += numNew; //链表大小调整
		return true;
	}

将集合中的元素添加到链表指定位置，方法具体解释见代码后的注释。

clear

public void clear() {
		Entry<E> e = header.next;
		while (e != header) {
			Entry<E> next = e.next;
			e.next = e.previous = null;
			e.element = null;
			e = next;
		}
		header.next = header.previous = header;
		size = 0;
		modCount++;
	}

清空链表

get

public E get(int index) {
		return entry(index).element;
	}

返回某个位置的值

set

public E set(int index, E element) {
		Entry<E> e = entry(index);
		E oldVal = e.element;
		e.element = element;
		return oldVal;
	}

设置某个位置的值

indexOf

public int indexOf(Object o) {
		int index = 0;
		if (o == null) {
			for (Entry e = header.next; e != header; e = e.next) {
				if (e.element == null)
					return index;
				index++;
			}
		} else {
			for (Entry e = header.next; e != header; e = e.next) {
				if (o.equals(e.element))
					return index;
				index++;
			}
		}
		return -1;
	}

返回某个元素在链表中首次出现的位置，未找到则返回-1

lastIndexOf

public int lastIndexOf(Object o) {
		int index = size;
		if (o == null) {
			for (Entry e = header.previous; e != header; e = e.previous) {
				index--;
				if (e.element == null)
					return index;
			}
		} else {
			for (Entry e = header.previous; e != header; e = e.previous) {
				index--;
				if (o.equals(e.element))
					return index;
			}
		}
		return -1;
	}

返回某个元素在链表中最后出现的位置，未找到则返回-1

peek

public E peek() {
		if (size == 0)
			return null;
		return getFirst();
	}

返回链表中的第一元素

element

public E element() {
		return getFirst();
	}

返回链表中的第一个元素，该方法同上面的peek方法的区别在于当链表为空时，peek返回为null，而element方法抛出NoSuchElementException异常

poll

public E poll() {
		if (size == 0)
			return null;
		return removeFirst();
	}

返回链表中的第一个元素，并将其在链表中移除，当链表为空时返回null

remove

public E remove() {
		return removeFirst();
	}

返回链表中的第一个元素，并将其从链表中移除，当链表为空时抛出NoSuchElementException异常

offer

public boolean offer(E e) {
		return add(e);
	}

在链表的尾部加入元素

offerFirst

public boolean offerFirst(E e) {
		addFirst(e);
		return true;
	}

在链表的头部加入元素

offerLast

public boolean offerLast(E e) {
		addLast(e);
		return true;
	}

在链表的尾部加入元素

peekFirst

public E peekFirst() {
		if (size == 0)
			return null;
		return getFirst();
	}

返回链表第一个元素，当链表为空时返回null

peekLast

public E peekLast() {
		if (size == 0)
			return null;
		return getLast();
	}

返回链表的最后一个元素，当链表为空时返回null

entry

private Entry<E> entry(int index) {
		if (index < 0 || index >= size)
			throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
					+ size);
		Entry<E> e = header;
		if (index < (size >> 1)) {
			for (int i = 0; i <= index; i++)
				e = e.next;
		} else {
			for (int i = size; i > index; i--)
				e = e.previous;
		}
		return e;
	}

该方法为私有方法，返回某个位置的元素