LinkedList源代码阅读

目录

前言

一、什么是LinkedList？

1、类结构：

2、成员变量

3、构造方法

二、主要方法

--------------------------------------作为列表------------------------------------

1.添加元素

2.删除元素

 3.获取元素

 4.修改元素

 -----------------------------------双端接口------------------------------------

1.入队

2.出队

 3.获取元素

总结

---

前言

        在集合类中,List是最基础的一种集合:它是一种有序列表。既可以通过数组实现（ArrayList），也可以通过链表形式实现（LinkedList），本文将通过源码简单了解LinkedList。

一、什么是LinkedList？

1、类结构：

public class ArrayList extends AbstractList
        implements List, RandomAccess, Cloneable, java.io.Serializable

                简单说，LInkedLIst就是（1）List接口，（2）Queue接口，（3）Cloneable接口和（4）Serializable接口的一个实现类。

特点：（1）实现类具有有序、允许值重复的特点。

           （2）可以做为双端队列进行操作。

           （3）覆盖了函数clone()，所以它能被克隆。

           （4）可序列化，能通过序列化进行传输。
       

2、成员变量

// LinkedList集合元素个数（逻辑大小）
transient int size = 0;
// 双向链表的头节点
transient Node first;
// 双向链表的尾节点
transient Node last;

        LinkedList 的属性比较不多，链表中元素的个数（size）以及头节点(first)、尾节点(last)。

3、构造方法

public LinkedList() {
    }
 
 
public LinkedList(Collection c) {
        this();
        addAll(c);
    }

          LinkedList给我们提供了有参和无参两种构造方法。有参构造方法传入一个集合，先调用了无参构造方法初始化，后使用addAll()【详细见下文】方法将集合的数据添加到链表中。 

二、主要方法

--------------------------------------作为列表------------------------------------

1.添加元素

        (1)boolean add（E  e）方法: 添加新元素，返回值为boolean类型

public boolean add(E e) {
    linkLast(e);
    return true;
}

        默认添加到队尾，调用了linkLast()方法，设置元素e为最后一个元素。

        ****linkLast()****

void linkLast(E e) {
	// 获取链表的最后一个节点
    final Node l = last;
    // 创建一个新节点
    final Node newNode = new Node<>(l, e, null);
    // 使新的一个节点为最后一个节点
    last = newNode;
    // 如果最后一个节点为null，则表示链表为空，则将newNode赋值给first节点
    if (l == null)
        first = newNode;
    else
    	// 否则尾节点的last指向 newNode
        l.next = newNode;
    // 元素的个数加1
    size++;
    // 修改次数自增
    modCount++;

        （2）void add(int index, E element) 方法:在指定 index 处插入元素

public void add(int index, E element) {
	// 检查索引index的位置
    checkPositionIndex(index);
	// 如果index==size，直接在链表的最后插入元素，相当于add(E e)方法
    if (index == size)
        linkLast(element);
    else
    	// 否则调用node方法将index位置的节点找出，接着调用linkBefore 方法
        linkBefore(element, node(index));
}

         （3）boolean addAll(Collection c)方法:在 LinkedList 中按顺序依次添加集合 c 中的所有元素.

public boolean addAll(Collection c) {
        return addAll(size, c);
    }
 //将集合c依次从末尾添加至LinkedList集合中，
 public boolean addAll(int index, Collection c) {
        checkPositionIndex(index);// 保证索引不越界
        Object[] a = c.toArray();//将集合c转为Object[]数组临时保存
        int numNew = a.length;
        if (numNew == 0) //如果新数组长度为0，则返回flase
            return false;
        Node pred, succ;
        if (index == size) {//如果index == size 直接在末尾添加
            succ = null;
            pred = last;
        } else {  //获取 index 前一个 node 节点，从中间插入。
            succ = node(index);
            pred = succ.prev;
        }
          //获取 index 前一个 node 节点，从中间插入。
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node 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;
    }

2.删除元素

        （1）E remove()方法：删除链表中元素，返回被删除元素。

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

         默认删除首部元素，调用了removeFirst()方法，删除后返回。   

        ****removeFirst()****  

public E removeFirst() {
    final Node f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}

        （2）remove(int index) 方法，删除指定位置的元素

public E remove(int index) {
	// 检查索引index的位置
    checkElementIndex(index);
    // 调用node方法获取节点，接着调用unlink(E e)方法删除并返回	
    return unlink(node(index));
}

E unlink(Node x) {
    // assert x != null;
    // 获得节点的三个属性
    final E element = x.item;
    final Node next = x.next;
    final Node 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;
    }
	
	// 把item置为null，让垃圾回收器回收
    x.item = null;
     // 移除一个节点，size自减
    size--;
    modCount++;
    return element;

}

        （3）void clear()方法：删除所有元素（清空链表）

 3.获取元素

        （1）E getFirst()方法：获取链表中的头元素。

public E getFirst() {
        final Node f = first;
        if (f == null)
        //头元素为空,则抛出迭代异常
            throw new NoSuchElementException();
        return f.item;
}

        （2） E lastFirst()方法：获取链表中的尾元素。

public E getLast() {
        final Node l = last;
        if (l == null)
        //尾元素为空，抛出迭代异常
            throw new NoSuchElementException();
        return l.item;
}

        （3） E get(int index)方法：获取指定位置的元素。

public E get(int index) {
        //检查索引合法
        checkElementIndex(index);
        return node(index).item;
    }

 4.修改元素

        set(int index, E element)方法，修改指定位置的元素。 

public E set(int index, E element) {
    checkElementIndex(index);
    // 通过node(int index)找到对应下标的元素
    Node x = node(index);
     // 取出该节点的元素，供返回使用
    E oldVal = x.item;
     // 用新元素替换旧元素
    x.item = element;
    // 返回旧元素
    return oldVal;
}

 -----------------------------------双端接口------------------------------------

1.入队

         (1)offerFirst(E e) 方法，从队头入。

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

       （2）offerLast(E e)方法，从队尾入。

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

2.出队

        （1）pollFirst()方法,从头出。（返回删除的头元素）

public E pollFirst() {
    final Node f = first;
    return (f == null) ? null : unlinkFirst(f);
}

        （2）pollLast()方法，从尾出。（返回删除的尾元素）

public E pollLast() {
      final Node l = last;
      return (l == null) ? null : unlinkLast(l);
}

 3.获取元素

        （1） peekFirst()方法，获取头部元素（不删除）

public E peekFirst() {
     final Node f = first;
     return (f == null) ? null : f.item;
}

         （2） peekList()方法，获取尾部元素（不删除）

public E peekLast() {
    final Node l = last;
    return (l == null) ? null : l.item;
}

---

总结

        以上就是今天分享的内容，本文仅仅简单介绍了LinkedList的一些内容，而LinkedList提供了大量能使我们快速便捷地处理数据的方法。