LinkedList详解

LinkedList详解

基本介绍

• LinkedList 底层实现了双向链表和双端队列的特点

• 可以添加任意元素(元素可以重复)，包括null

• 线程不安全，没有实现同步

LinkedList 的底层操作机制

• LinkedList 底层维护了一个双向链表

• LinkedList 中维护了两个属性 first 和 last 分别指向 首节点和尾节点

• 每个节点（Node对象），里面又维护了prev、next、item三个属性，其中通过prev指向前一个节点，通过next指向后一个节点。最终实现双向链表。

• item 用来存放数据

• 所以LinkedList的元素的添加和删除，不是通过数组来完成的，相对来说效率较高

模拟一个简单的双向链表

public class Demo05 {
    public static void main(String[] args) {
        Node jack = new Node("jack");
        Node tom = new Node("tom");
        Node jay = new Node("jay");
​
        jack.next = tom;
        tom.next = jay;
        jay.pre = tom;
        tom.pre = jack;
​
        Node first = jack;
        Node last = jay;
​
        System.out.println("===从头到尾进行遍历===");
        while (true) {
            if (first == null) {
                break;
            }
            System.out.println(first);
            first = first.next;
        }
        
        System.out.println("===从尾到头进行遍历===");
        while (true) {
            if (last == null) {
                break;
            }
            System.out.println(last);
            last = last.pre;
        }
        
        //在tom和jay之间插入一个 smith
        Node smith = new Node("smith");
        smith.next = jay;
        smith.pre = tom;
        jay.pre = smith;
        tom.next = smith;
​
        first = jack; //让first再次指向jack
        System.out.println("===从头到尾进行遍历===");
        while (true) {
            if (first == null) {
                break;
            }
            System.out.println(first);
            first = first.next;
        }
​
    }
}
//定义一个Node类，Node对象表示双向链表的一个节点
class Node{
    public Object item; //存放数据
    public Node next;
    public Node pre;
​
    public Node(Object name) {
        this.item = name;
    }
​
    public String toString() {
        return "Node name" +item;
    }
}

LinkedList 的源码解读

public class Demo06 {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        System.out.println(linkedList);
        
        linkedList.remove(); //默认删除的是链表的第一个节点
        System.out.println(linkedList);
        
        linkedList.set(1,999); //修改某个节点对象的数据
        System.out.println(linkedList);
        
        Object o = linkedList.get(1);//得到某个节点对象
        System.out.println(o);
       
        System.out.println("===LinkedList迭代器遍历===");
        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println("next="+next);
        }
        
        System.out.println("===LinkedList增强for循环遍历===");
        for (Object o1 : linkedList) {
            System.out.println("o1="+o1);
        }
        
        System.out.println("===LinkedList普通for循环遍历===");
        for (int i = 0; i <linkedList.size() ; i++) {
            System.out.println(linkedList.get(i));
        }
    }
}

---

---

• 1.执行 LinkedList linkedList = new LinkedList();

  • 这时 LinkedList的属性 first = null、last = null

public LinkedList() {
}

• 2.执行 linkedList.add(1);

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

• 3.执行 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++;
}

• 4.执行 linkedList.add(2);

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

• 5.执行 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++;
}

• 6.执行 linkedList.add(3); 同上

---

---

• 7.执行 linkedList.remove();

  • 默认删除的是链表的第一个节点

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

• 8.执行 return removeFirst();

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

• 9.执行 return unlinkFirst(f);

  • 将 f 指向的双向链表的第一个节点删掉

private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
    final E element = f.item;
    final Node<E> next = f.next;
    f.item = null;
    f.next = null; // help GC
    first = next;
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}