心在山东身在吴，飘蓬江海漫嗟吁。
他时若遂凌云志， 敢笑黄巢不丈夫。
——水浒传
先上源代码,LinkedList类:
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;
}
}
Java链表中定义了一个内部类Node类,"node"是节点的意思.链表的基本元素是节点,(双向链表)每个节点包含三个成员,分别是item:数据,next:指向链表下一个元素的指针,prev:指向上一个元素的指针
先看一下C中的链表：
头指针变量保存了一个地址，它指向一个变量No.1，No.1中又保存了一个指针，它指向No.2，以此类推，直到No.X中保存的地址指向No.last，图中最后一项为No.3，它指向NULL。
双向链表每个元素中又加入了prev指针。
双向链表图：
但是java中没有指向内存地址的指针，那么如何实现链表呢？
再看Java源代码：
transient int size = ;
/**
* Pointer to first node.
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
transient Node<E> first;
/**
* Pointer to last node.
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
transient Node<E> last;
/**
* Constructs an empty list.
*/
public LinkedList() {
}
/**
* Constructs a list containing the elements of the specified
* collection, in the order they are returned by the collection's
* iterator.
*
* @param c the collection whose elements are to be placed into this list
* @throws NullPointerException if the specified collection is null
*/
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
LinkedList类定义了两个临时节点first和last,两个构造器.一个无参构造和一个带参构造,无参构造创建链表实例,带参构造可以把一个集合整体加入链表
下面看一下add()方法:
public boolean add(E e) {
linkLast(e);
return true;
}
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++;
modCount++;
}
画图:
初始链表为空的情况：prev和next都是null,item是e,这里假设传入的数据是No.1,No.2...;
此时再加入元素：
加入第三个元素：
加入第四个元素：
以此类推。。。
可见java中链表是用引用变量指向节点来代替C中的指针变量指向内存地址。
每次加入新的元素，只需要将原last元素的next指向新加入元素的实例，把新加入元素的prev指向原last元素的实例。
再看下add(int index, E element)方法:
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> )) {
Node<E> x = first;
for (int i = ; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - ; i > index; i--)
x = x.prev;
return x;
}
}
这里假定传入的index比size小,
node(int index)用很简单的方式返回了位置为index的Node实例,然后执行linkBefore(E e, Node<E> succ)方法
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++;
}
把newNode 的prev 指向原位置节点的prev节点,next 指向原位置节点;
把原位置节点的prev指向newNode;
最后把原位置节点的prev节点(如果有)的next指向newNode;如果没有,则newNode为第一个节点,原位置节点变为第二个节点;
此处省略其他链表方法...原理是一样的.