手动实现LinkedList

LinkedList

List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。

构造方法摘要

LinkedList() 构造一个空列表。
LinkedList(Collection<? extends E> c) 构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。

方法摘要

boolean add(E e) 将指定元素添加到此列表的结尾。
void add(int index, E element) 在此列表中指定的位置插入指定的元素。
void clear() 从此列表中移除所有元素。
boolean contains(Object o) 如果此列表包含指定元素，则返回 true。
E get(int index) 返回此列表中指定位置处的元素。
E getFirst() 返回此列表的第一个元素。
E getLast() 返回此列表的最后一个元素。
int indexOf(Object o) 返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
int lastIndexOf(Object o) 返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
E remove() 获取并移除此列表的头（第一个元素）。
E remove(int index) 移除此列表中指定位置处的元素。
boolean remove(Object o) 从此列表中移除首次出现的指定元素（如果存在）。
E removeFirst() 移除并返回此列表的第一个元素。
E removeLast() 移除并返回此列表的最后一个元素。
E set(int index, E element) 将此列表中指定位置的元素替换为指定的元素。
int size() 返回此列表的元素数。
Object[] toArray() 返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。

手动实现

import java.util.NoSuchElementException;

public class LinkedList<E> {
	transient int size = 0;// 链表大小
	transient Node<E> first;
	transient Node<E> last;

	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;
		}
	}

	private void linkFirst(E e) {// 将指定元素插入此列表的开头
		final Node<E> f = first;
		final Node<E> newNode = new Node<>(null, e, f);
		first = newNode;
		if (f == null)
			last = newNode;
		else
			f.prev = newNode;
		size++;
	}

	void linkLast(E e) {// 将指定元素插入此列表的结尾
		final Node<E> l = last;
		final Node<E> newNode = new Node<>(l, e, null);
		last = newNode;
		if (l == null)
			first = newNode;
		else
			l.next = newNode;
		size++;
	}

	public boolean add(E e) {
		linkLast(e);// 将元素添加到链表末尾
		return true;
	}

	private boolean isPositionIndex(int index) {// 判断下标是否在指定范围
		return index >= 0 && index <= size;
	}

	private void checkPositionIndex(int index) {// 检查下标是否越界，下标可以为链表大小
		if (!isPositionIndex(index))// 越界，抛出错误信息
			throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
	}

	private Node<E> node(int index) {// 获取index所对应的Node元素
		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;
		}
	}

	private void linkBefore(E e, Node<E> succ) {
		final Node<E> pred = succ.prev;
		final Node<E> newNode = new Node<>(pred, e, succ);
		succ.prev = newNode;// 新节点的prev是原index元素的prev,新节点的next是原index元素
		if (pred == null)
			first = newNode;
		else
			pred.next = newNode;
		size++;// 大小加1
	}

	public void add(int index, E element) {// 在指定位置插入元素
		checkPositionIndex(index);// 检查下标
		if (index == size)// 如果下标为链表大小
			linkLast(element);// 在末尾添加元素
		else
			linkBefore(element, node(index));// 在原来的index元素前插入指定元素
	}

	public void clear() {// 移除所有元素
		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;// 设置链表大小为0
	}

	public int indexOf(Object o) {// 返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1
		int index = 0;// 设置初始下标为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;
	}

	public int lastIndexOf(Object o) {// 返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1
		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;
	}

	public boolean contains(Object o) {// 判断是否包含指定元素
		return indexOf(o) != -1;// 判断是否找到元素下标
	}

	private void checkElementIndex(int index) {// 检查下标是否越界
		if (index >= 0 && index < size)
			throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
	}

	public E get(int index) {// 返回指定位置处的元素
		checkElementIndex(index);// 检查是否越界
		return node(index).item;// 返回index所在的元素
	}

	public E getFirst() {// 返回第一个元素
		final Node<E> f = first;// 头节点
		if (f == null)// 如果头节点为空
			throw new NoSuchElementException();// 抛出异常
		return f.item;// 返回头节点的数据域
	}

	public E getLast() {// 返回最后一个元素
		final Node<E> l = last;
		if (l == null)
			throw new NoSuchElementException();// 抛出异常
		return l.item;// 返回尾节点的数据域
	}

	private E unlinkFirst(Node<E> f) {// 移除头节点
		final E element = f.item;
		final Node<E> next = f.next;
		f.item = null;
		f.next = null;
		first = next;
		if (next == null)
			last = null;
		else
			next.prev = null;
		size--;
		return element;
	}

	private E unlinkLast(Node<E> l) {// 移除尾节点
		final E element = l.item;
		final Node<E> prev = l.prev;
		l.item = null;
		l.prev = null;
		last = prev;
		if (prev == null)
			first = null;
		else
			prev.next = null;
		size--;
		return element;
	}

	E unlink(Node<E> x) {// 移除指定元素
		final E element = x.item;
		final Node<E> next = x.next;
		final Node<E> prev = x.prev;

		if (prev == null) {
			first = next;
		} else {
			prev.next = next;
			x.prev = null;
		}

		if (next == null) {
			last = prev;
		} else {
			next.prev = prev;
			x.next = null;
		}

		x.item = null;
		size--;
		return element;
	}

	public E removeFirst() {// 移除并返回此列表的第一个元素
		final Node<E> f = first;
		if (f == null)// 为空
			throw new NoSuchElementException();// 抛出异常
		return unlinkFirst(f);
	}

	public E removeLast() {// 移除并返回此列表的最后一个元素
		final Node<E> l = last;
		if (l == null)
			throw new NoSuchElementException();// 抛出异常
		return unlinkLast(l);
	}

	public E remove() {// 移除并返回此列表的第一个元素
		return removeFirst();
	}

	public E remove(int index) {// 移除此列表中指定位置处的元素
		checkElementIndex(index);// 检查下标是否越界
		return unlink(node(index));
	}

	public boolean remove(Object o) {// 从此列表中移除首次出现的指定元素（如果存在）
		int index = indexOf(o);// 返回第一次出现的下标
		if (index < 0) {// 如果不存在
			return false;// 移除失败
		}
		unlink(node(index));// 存在则移除指定元素
		return true;
	}

	public E set(int index, E element) {// 修改指定位置的元素为指定的元素
		checkElementIndex(index);// 下标是否越界
		Node<E> x = node(index);
		E oldVal = x.item;
		x.item = element;
		return oldVal;// 以前在指定位置的元素
	}

	public int size() {// 返回此列表的元素数
		return size;
	}

	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;// 返回数组
	}
}

简单测试

public class TL {

	public static void main(String[] args) {
		LinkedList<String> l = new LinkedList<>();
		l.add("a");
		l.add("b");
		l.add("c");
		l.add(2, "d");
		l.add(2, "aaa");
		Print(l);
		System.out.println("第一个元素：" + l.getFirst());
		System.out.println("最后一个元素：" + l.getLast());
		System.out.println("是否包含aa: " + l.contains("aa"));
		System.out.println("首次出现指定元素a的下标：" + l.indexOf("a"));
		l.remove(3);
		l.remove("a");
		l.set(0, "改了哦");
		Print(l);

	}

	public static void Print(LinkedList<String> l) {
		for (int i = 0; i < l.size(); i++)
			System.out.print(l.get(i) + " ");
		System.out.println();
	}

}

结果：

a b aaa d c 
第一个元素：a
最后一个元素：c
是否包含aa: false
首次出现指定元素a的下标：0
改了哦 aaa c 

总结：
以上代码，仅供参考。LinkedList 由双向链表实现， 查询效率低，修改效率高