LinkedList核心知识点-----源码解析

目录

 

基本原理以及优缺点

原理

优点

缺点

与arrayList的对比

场景分析

应用不能频繁的随机访问数据适合使用

应用应该是更多的插入和删除元素.更少的读取数据.

尤其是LinkedList其实是当做队列来用的.比如当做内存队列,因为其根据链表实现的,天然可以做队列的数据结构.先进先出.也不会导致数组扩容

但是在工作中使用,一般都是用java并发包下面的一些线程安全的集合,可以参考并发包下的集合.

linkedList数据结构

数组加链表实现

linkedList的双向链表数据结构,所有的增删改都基于这个链表进行的.

集合操作

插入元素

获取元素

删除元素.

---

基本原理以及优缺点

 

原理

 

• 基于双向链表实现的,一个节点挂着另外一个节点.

 

优点

 

• 链表是无界的.所以大量的插入元素没有大小限制,不需要扩容.
• 插入元素时只需要将新节点挂上就行了.即使是中间插入,也只是小部分遍历查找到节点插入位置.不要挪动大量元素.
• 非常适合各种元素频繁插入的场景.

 

缺点

 

• 不适合随机读.在随机的位置获取某个位置的元素,比如linkedList.get(10)这种操作,性能比较低
• 因为需要遍历这个链表.从头开始遍历,直到找到index=10的这个元素为止.

 

与arrayList的对比

 

• 一个是数组实现,一个是双向链表实现,分别讲下优缺点,
• 并讲下数组扩容,元素移动原理,
• 双向链表就现场画下数据结构,指针,node如何变化的.讲下队列头部加元素/获取元素/删除元素. 队列尾部删除元素/获取元素/加元素/以及队列中间加元素,获取元素/删除元素.

 

场景分析

 

应用不能频繁的随机访问数据适合使用

 

应用应该是更多的插入和删除元素.更少的读取数据.

 

尤其是LinkedList其实是当做队列来用的.比如当做内存队列,因为其根据链表实现的,天然可以做队列的数据结构.先进先出.也不会导致数组扩容

 

 

但是在工作中使用,一般都是用java并发包下面的一些线程安全的集合,可以参考并发包下的集合.

 

linkedList数据结构

 

数组加链表实现

 

linkedList的双向链表数据结构,所有的增删改都基于这个链表进行的.

 

集合操作

 

插入元素

• 在尾部插入元素add(E e)=addLast()

 

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

 

 

/**
• Links e as first element.
*/
private void linkFirst(E e) {
    final Node f = first;
    final Node newNode = new Node<>(null, e, f);
    first = newNode;
    if (f == null)
     last = newNode;
    else
        f.prev = newNode;
    size++;
    modCount++;
}

 

 

• 数据结构变动如下图
• 效率很高

 

• 在头部插入元素addFirst()

 

 public void addFirst(E e) {
    linkFirst(e);
}

 

private void linkFirst(E e) {
    final Node f = first;
    final Node newNode = new Node<>(null, e, f);
    first = newNode;
    if (f == null)
     last = newNode;
    else
     f.prev = newNode;
    size++;
    modCount++;
}

 

- 数据结构变动如上图
- 效率很高.

 

• 在中间插入元素add(index),element

- public void add(int index, E element) {
    checkPositionIndex(index);
        if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

 

void linkBefore(E e, Node succ) {
// assert succ != null;
    final Node pred = succ.prev;
    final Node newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

 

Node node(int index) {
    // assert isElementIndex(index);
    //经典的链表遍历.面试算法可能会有,这里的size >>1代表除以2的意思
    if (index < (size >> 1)) {
        Node x = first;
        for (int i = 0; i < index; i++)
        x = x.next;
        return x;
    } else {
        Node x = last;
        for (int i = size - 1; i > index; i--)
        x = x.prev;
        return x;
    }
}

 

• 数据结构变动如上图
• 这里的代码可以学习一下,有可能面试或者算法里面会有.
• 效率相对数组比较低.数组是直接通过index就可以在内存中取出.而链表却需要折半遍历

 

获取元素

 

• 获取头部元素getFirst()==peek()

 

-  public E getFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return f.item;
}
- 直接获取头部节点.通过节点对象取item元素即可,效率较高

 

• 获取尾部元素getLast()

 

- public E getLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return l.item;
}
- 直接获取尾部节点,通过节点获取其item节点,效率较高

 

• 获取指定位置的元素get(int index)

 

- public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}
- 这里的node方法根上面一样,直接折半判断index索引是在链表前部还是后部,然后进行链表遍历获取最终index索引所在位置的元素并返回.效率较低

 

删除元素.

• 删除头部元素removeFirst()=pop()

 

-   private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
    //获取头部元素
    final E element = f.item;
    //获取头部next指针对应的节点
    final Node next = f.next;
    f.item = null;//删除元素
    //删除next指针节点,帮助垃圾回收
    f.next = null; // help GC
    first = next;//将next节点变为fisrt节点
    if (next == null)
    last = null;
    else
    next.prev = null; //next节点的前指针变为null
    size--;
    modCount++;
    return element;
}

 

• 删除尾部元素removeLast()

 

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

 

• 删除指定元素

- 移除某个元素时,从头遍历,直到遍历出元素为null的进行unlink,这里判断是否为null的原因是==是直接比较的两个对象的堆内存地址,而另一方面防止对象中equals方法被重写.所以要分开判断
-      public boolean remove(Object o) {
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}
- 下面是具体的unlink代码删除某个元素.可以看到将某个节点的元素取出置为null并返回.该节点的左右指针全部置为null,并将该节点两侧的节点通过prev和next指针进行连接.
E unlink(Node<E> x) {
    // assert x != null;
    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--;
    modCount++;
    return element;
}

 

思维导图如下: