Java-链表LinkedList源码原理分析,并且通过LinkedList构建队列

在这里我们介绍一下最简单的链表LinkedList;

看一下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++;
    }

add原理就是:

1.首先获取链表最后一个节点。

2.把新节点插入到最后一个节点之后。

3.linkedList的last属性重新指向最后一个节点。

4.如果这个节点是第一个节点,之前没有节点,那么将linkedList的first的属性指向新节点;如果不是,则将上一个节点的next属性指向该节点。

 

使用LinkedList构建先进先出队列:

offer()方法入队:使用add()方法插入节点在最后。

public boolean offer(E e) {
        return add(e);
    }

poll()方法出队:从链表表头开始移出队列

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

 

使用LinkedList构建后进先出队列:

push()方法入队:插入节点在first

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

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

pop()方法出队:从链表表头开始移出队列

public E pop() {
        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;
        f.item = null;
        f.next = null; // help GC
        first = next;
        if (next == null)
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        return element;
    }

 

最后需要注意的是:LinkedList是线程不安全的,如果需要线程安全那么请使用synchronized加锁,或者使用vector,或者使用java.util.concurrent包。

如果需要线程遍历List的时候,避免出现ConcurrentModificationException异常,那么有3种解决方式。

1.遍历List的使用synchronized加锁;

2.使用java.util.concurrent包下面的CopyOnWriteArrayList,每次使用List时实际上都是使用的List副本。

3.使用Jdk8中foreach方法,不过该方法只接受lambda表达式

list.forEach(item -> {
                    System.out.println("遍历元素:" + item);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });

 

    原文作者:11楼的日记
    原文地址: https://www.cnblogs.com/eoss/p/5948868.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞