Java--LinkedList集合，链表

Posted 2022-02-24 MinggeQingchun

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java--LinkedList集合，链表相关的知识，希望对你有一定的参考价值。

一、LinkedList

LinkedList 继承了 AbstractSequentialList 类，实现了 List 接口，可进行列表的相关操作

LinkedList 实现了 Queue 接口，可作为队列使用。

LinkedList 实现了 Deque 接口，可作为队列使用。

LinkedList 实现了 Cloneable 接口，可实现克隆。

LinkedList 实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

    transient int size = 0;

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;

    /**
     * Constructs an empty list.
     */
    public LinkedList() 
    

    /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param  c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    public LinkedList(Collection<? extends E> c) 
        this();
        addAll(c);
    

    /**
     * Links e as first element.
     */
    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++;
    

    /**
     * Links e as last element.
     */
    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++;
    

    /**
     * Returns the first element in this list.
     *
     * @return the first element in this list
     * @throws NoSuchElementException if this list is empty
     */
    public E getFirst() 
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    

    /**
     * Returns the last element in this list.
     *
     * @return the last element in this list
     * @throws NoSuchElementException if this list is empty
     */
    public E getLast() 
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    

    /**
     * Removes and returns the first element from this list.
     *
     * @return the first element from this list
     * @throws NoSuchElementException if this list is empty
     */
    public E removeFirst() 
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    

    /**
     * Removes and returns the last element from this list.
     *
     * @return the last element from this list
     * @throws NoSuchElementException if this list is empty
     */
    public E removeLast() 
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    

    /**
     * Inserts the specified element at the beginning of this list.
     *
     * @param e the element to add
     */
    public void addFirst(E e) 
        linkFirst(e);
    

    /**
     * Appends the specified element to the end of this list.
     *
     * <p>This method is equivalent to @link #add.
     *
     * @param e the element to add
     */
    public void addLast(E e) 
        linkLast(e);
    

    public int size() 
        return size;
    

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

    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;
    


    public E get(int index) 
        checkElementIndex(index);
        return node(index).item;
    

    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;

ArrayList之所以检索效率比较高，不是单纯因为下标的原因，是因为底层数组发挥的作用。LinkedList集合照样有下标，但是检索/查找某个元素的时候效率比较低，因为只能从头节点开始一个一个遍历。

链表的优点：由于链表上的元素在空间存储上内存地址不连续。所以随机增删元素的时候不会有大量元素位移，因此随机增删效率较高。遇到随机增删集合中元素的业务比较多时，优先使用LinkedList。

链表的缺点：不能通过数学表达式计算被查找元素的内存地址，每一次查找都是从头节点开始遍历，直到找到为止。因此LinkedList集合检索/查找的效率较低。