目录
allAll(Collection c)、addAll(int index, Collection c)
数据结构
LinkedList的数据结构也比较简单，就是一个双向链表，基本的存储结构代码如下（是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;
}
}包括自己的值（item）,前一个节点的信息（prev）,下一个节点信息（next）。
构造方法
有两个构造方法：
无参数的构造方法：
public LinkedList() {}带参数的构造方法：
//入参是一个集合，也就是希望在创建LinkedList的时候就把传入的这些数据放进去
public LinkedList(Collection<? extends E> c) {
this();
//将参数传入的数据添加进去
addAll(c);
}
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
/*
index 在哪个位置插入（可以指定插入位置，这儿传入的是size，也就是从链表的尾部插入）
c 数据
*/
public boolean addAll(int index, Collection<? extends E> c) {
//检查参数index是否超过链表长度（这儿肯定不会超过）
checkPositionIndex(index);
//将传入的集合转化为数组
Object[] a = c.toArray();
int numNew = a.length;
//如果传入的集合为空，则直接结束
if (numNew == 0)
return false;
Node<E> pred, succ;
if (index == size) {
//在链表尾部插入，构造方法就是在链表尾部插入
//succ是在指定位置插入的时候使用的，
succ = null;
//pred记录尾节点信息
pred = last;
} else {
//在链表中指定的位置插入
//此时首先要找到index所在位置的节点
succ = node(index);
//先记录指定节点的前一个节点的信息（后面会用到）
pred = succ.prev;
}
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
//创建一个新节点，新节点的前一个节点就是pred(pred始终是链表的尾节点)
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)
//如果链表原来就是空的，那新节点也就是第一个节点
first = newNode;
else
/*如果链表不是空的，那尾节点的下一个节点就是新创建的节点（新节点的前一个节点在创建的时候已经指定了）*/
pred.next = newNode;
//在将pred指向新节点（新节点也就是尾节点，pred始终指向尾节点）
pred = newNode;
}
if (succ == null) {
//尾部插入，pred就是尾节点
last = pred;
} else {
//指定位置插入，注意pred始终指向新创建链表的尾节点
//此时将succ（指定位置的节点）赋给pred的next信息
pred.next = succ;
//succ(指定位置节点)的前一个节点就是新创建节点的最后一个节点，这样就完成了在指定位置插入的操作
succ.prev = pred;
}
//链表数据量
size += numNew;
//链表修改次数
modCount++;
return true;
}
//找出index位置的节点
Node<E> node(int index) {
// assert isElementIndex(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;
}
}字段说明
//链表中的数据量
transient int size = 0;
//链表头结点
transient Node<E> first;
//链表尾节点
transient Node<E> last;
方法详解
add(E e)
插入元素e，Appends the specified element to the end of this list（在链表的尾部插入指定的元素）
//可以看出该方法是后插（新节点链接到链表尾部）
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和last是同一个节点
first = newNode;
else
//否则，将新节点链接到原来尾节点的后面
l.next = newNode;
size++;
modCount++;
}add(int index, E element)
在index位置插入元素element
public void add(int index, E element) {
//index是否超过链表长度
checkPositionIndex(index);
if (index == size)
//尾部插入
linkLast(element);
else
//指定位置的前面插入,首先需要获取index位置的节点(前面讲构造方法的时候有)
linkBefore(element, node(index));
}
//校验index是否超过链表长度
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//链表尾部插入(前面的add方法有提到)
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++;
}
//找到index指定位置的节点
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;
}
}
//在succ的前面插入e
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
//先记录succ的前一个节点信息
final Node<E> pred = succ.prev;
//创建新节点，新节点的前一个节点就是succ原来的前一个节点，新节点的下一个节点就是succ
final Node<E> newNode = new Node<>(pred, e, succ);
//succ的前一个节点设置为新节点
succ.prev = newNode;
if (pred == null)
//如果succ的前一个节点为空的话，说明原来succ就是头结点，那么插入以后新节点就是头结点了
first = newNode;
else
//succ原来前一个节点的下一个节点就变成新节点了
pred.next = newNode;
size++;
modCount++;
}addFirst(E e)
看该方法的注释就比较清楚了：Inserts the specified element at the beginning of this list.（在列表的开头插入指定的元素）
public void addFirst(E e) {
linkFirst(e);
}
private void linkFirst(E e) {
//记录旧的头结点
final Node<E> f = first;
//创建新节点，因为是在头部插入，所以前一个节点信息是null，后一个节点就是f（原来的头结点）
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
//如果链表原来是空的，则新节点即是头结点，又是尾节点
last = newNode;
else
//如果队列不为空，则原来的头结点的前一个节点就是新节点
f.prev = newNode;
size++;
modCount++;
}addLast(E e)
Appends the specified element to the end of this list.(在链表的尾部插入指定元素)
和add(E e)方法除了返回值不同外，其他都相同
public void addLast(E e) {
linkLast(e);
}
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++;
}allAll(Collection<? extends E> c)、addAll(int index, Collection<? extends E> c)
将指定集合中的元素加入到链表中，第一个方法是在尾部插入，第二个方法是在指定位置插入。
这两个方法和带参数的构造方法逻辑是一样的，第一个方法里面调了第二个方法。
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}get(int index)
Returns the element at the specified position in this list.（返回列表上指定位置的元素）
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
//是否超过链表元素个数
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
//前面在指定位置插入的时候都是先找到指定位置的元素，就是通过该方法的
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;
}
}getFirst()
返回链表第一个元素值
/*返回链表中第一个元素的值，如果链表为空则抛出异常NoSuchElementException*/
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}getLast()
返回链表最后一个元素
//返回链表最后一个元素值，如果列表为空则抛出异常NoSuchElementException
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}remove()
Retrieves and removes the head (first element) of this list.（检索并删除链表的头）
不带参数，删除的是链表的头部
public E remove() {
return removeFirst();
}
public E removeFirst() {
final Node<E> f = first;
if (f == null) //如果链表我空，则抛出异常
throw new NoSuchElementException();
return unlinkFirst(f);
}
//能进入这个方法，就说明链表至少有一个元素
//入参是当前链表的头节点，也就是要删除的目标节点
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
//要返回的元素
final E element = f.item;
//头结点的后一个节点（如果列表多于一个元素的话，该节点就是头结点）
final Node<E> next = f.next;
//将要删除的节点的信息都置为null,帮助垃圾回收
f.item = null;
f.next = null; // help GC
//指定新的头结点
first = next;
if (next == null)
//如果链表只有一个节点，则删除头节点以后链表就为空了，所以last节点就是null了
last = null;
else
//链表有至少两个节点，next节点也就是新的头结点，头节点的前一个节点信息肯定就是null了
next.prev = null;
size--;
modCount++;
return element;
}remove(index index)
删除链表中指定位置的元素，返回值是删去的元素。
public E remove(int index) {
checkElementIndex(index);
//先找到要删除的节点
return unlink(node(index));
}
//找到要删除的节点
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;
}
}
//执行删除，要删除的节点为x
E unlink(Node<E> x) {
// assert x != null;
//记录x节点的值、后一个节点信息和前一个节点信息
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
if (prev == null) {
//x节点是头结点，则删除以后，x结点的后一个节点就是头结点了
first = next;
} else {
//x节点不是头结点，将x节点前一个节点的next信息置为x节点的后一个节点
prev.next = next;
//X节点的prev信息置为null
x.prev = null;
}
if (next == null) {
//x节点是尾节点,则删除以后x节点的前一个节点就是尾节点了
last = prev;
} else {
//x节点不是尾节点，将x节点后一个节点的prev信息置为x节点前一个节点
next.prev = prev;
//x节点的next信息置为null
x.next = null;
}
//将x节点的值也置为null
x.item = null;
size--;
modCount++;
return element;
}clear()
将链表中所有的元素都删除
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
//通过循环将链表中每一个节点的所有信息都置为null,帮助垃圾回收
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
//头尾节点也置为null
first = last = null;
//元素个数置为0
size = 0;
modCount++;
}contains(Object o)
返回指定元素在链表中的索引值
public boolean contains(Object o) {
return indexOf(o) != -1;
}
public int indexOf(Object o) {
int index = 0;
if (o == null) {
//如果传入元素为null，则返回链表中出现第一个null的位置索引
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
//通过equals方法比较是否相等
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}containsAll(Collection<?> c)
链表中是否包含集合c中的所有元素，只有有一个元素不包含，就返回false
public boolean containsAll(Collection<?> c) {
for (Object e : c) //遍历参数传入的集合
if (!contains(e)) //调前一个contains方法
return false;
return true;
}isEmpty()
链表是否为空
public boolean isEmpty() {
//size记录的是链表中元素的个数
return size() == 0;
}size()
链表中元素的数量
public int size() {
return size;
}set(int index, E element)
将指定位置的元素值设置为传入的值
public E set(int index, E element) {
checkElementIndex(index);
//先找到index所在位置的节点
Node<E> x = node(index);
//记录旧值，方法返回值为旧值
E oldVal = x.item;
//将index所在位置的节点的值设置为传入的值
x.item = element;
return oldVal;
}push(E e)
在链表的头部插入元素e，里面调了addFirst(E e)方法
public void push(E e) {
addFirst(e);
}pop()
删除链表中的第一个元素，和remove()方法的实现是一样的
public E pop() {
return removeFirst();
}peek()、peekFirst()、peekLast()
从代码可以看出前两个方法的实现是一模一样的，都是返回链表中第一个元素的值
peekLast返回链表最后一个元素的值
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}clone()
方法注解：Returns a shallow copy of this {@code LinkedList}. (The elements themselves are not cloned.)
从注解可以看出是浅克隆
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;
}toArray()
转为数组
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;
}iterator()
LinkedList中的普通迭代器是从AbstractSequentialList继承来的，可以从前向后遍历。
public Iterator<E> iterator() {
return listIterator();
}listIterator(int index)
从指定位置开始向前/向后遍历
//ListItr是LinkedList的一个内部类
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) {
next = (index == size) ? null : node(index);
nextIndex = index;
}
public boolean hasNext() {
return nextIndex < size;
}
public E next() {}
public boolean hasPrevious() {}
public E previous() {}
public int nextIndex() {}
public int previousIndex() {}
public void remove() {}
public void set(E e) {}
public void add(E e) {}
public void forEachRemaining(Consumer<? super E> action) {}
final void checkForComodification() {}
}使用方法：
public static void main(String[] args) {
LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(5);
linkedList.add(4);
linkedList.add(3);
//普通迭代器
System.out.println("普通迭代器：");
Iterator<Integer> iterator = linkedList.iterator();
while (iterator.hasNext()) {
Integer i = iterator.next();
System.out.println(i);
}
//从索引为2的位置开始向前
System.out.println("==================");
System.out.println("从索引为2的位置开始向前遍历：");
ListIterator<Integer> listIterator = linkedList.listIterator(2);
while (listIterator.hasPrevious()) {
Integer i = listIterator.previous();
System.out.println(i);
}
System.out.println("==================");
//从索引为1的位置开始向后遍历
System.out.println("从索引为1的位置开始向后遍历：");
listIterator = linkedList.listIterator(1);
while (listIterator.hasNext()) {
Integer i = listIterator.next();
System.out.println(i);
}
}执行结果：
有一点需要注意，从运行结果可以看出，向前遍历的时候，遍历结果是不包含索引所在位置的值（索引从0开始）；
但是从指定位置开始向后遍历的时候，遍历结果却是包含索引指定位置元素的。
总结
LinkedList是一个双向列表，ArrayList是数组。
比如要获取指定位置的元素，LinkedList在查询的时候需要一个一个的元素去遍历，直到遍历到指定的位置；但是ArrayList却可以直接通过下标获取到某个元素，很明显获取指定位置的元素ArrayList效率要比LinkedList高。
如果要删除指定位置的元素，LinkedList需要首先通过遍历获取到指定元素所在节点，然后修改一下相关元素的后一个节点信息以及前一个节点信息即可；但是ArrayList却没这么简单，是通过数组复制实现的，如果数据量比较大的话，这是个比较耗时的过程，所以如果要删除的话LinkedList的效率是比较高的。
在使用的时候可以根据具体情况，选择合适的存储结构。
扫一扫
391
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
