Java_LinkedList底层结构

LinkedList的说明：

1）LinkedList实现了双向链表和双端队列特点

2）可以添加任意元素（元素可以重复），包括null

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

LinkedList底层操作机制：

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

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

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

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

底层源码分析（以增删改查为例）：

java 复制代码

package com.ArrListStu.LinkedList_;

import java.util.Iterator;
import java.util.LinkedList;

@SuppressWarnings({"all"})
public class LinkedListCRUD {
    public static void main(String[] args) {

        LinkedList linkedList = new LinkedList();
        /*
        第一步 new LinkedList
        public LinkedList() {} 空参构造器
        这时，linkedList 的属性first = null，last = null

        第二步 执行add方法
        public boolean add(E e) {
            linkLast(e);
            return true;
        }
        linkLast(e); 也就是将first和last同时指向它

        第三步 进入linkLast()
        void linkLast(E e) {
            final Node<E> l = last;     //此时last = null
            final Node<E> newNode = new Node<>(l, e, null);
            last = newNode;
            if (l == null)
                first = newNode;
            else
                l.next = newNode;
            size++;
            modCount++;
        }
        将新的节点，加入到双向链表的最后
         */
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        System.out.println("linkedList=" + linkedList);

        linkedList.remove();
         /*
         linkedList.remove(); // 这里默认删除的是第一个结点
          1. 执行 removeFirst
            public E remove() {
                return removeFirst();
            }
         2. 执行
            public E removeFirst() {
                final Node<E> f = first;
                if (f == null)
                    throw new NoSuchElementException();
                return unlinkFirst(f);
            }
          3. 执行 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;
            }
         */
        System.out.println("linkedList=" + linkedList);

        linkedList.set(1, 999);
        System.out.println("linkedList=" + linkedList);


        Object o = linkedList.get(1);
        System.out.println(o);//999

        System.out.println("===LinkeList遍历迭代器====");
        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println("next=" + next);

        }

        System.out.println("===LinkeList遍历增强for====");
        for (Object o1 : linkedList) {
            System.out.println("o1=" + o1);
        }
        System.out.println("===LinkeList遍历普通for====");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
    }
}

ArrayList和LinkedList比较：

如何选择ArrayList和LinkedList：

1）如果改查的操作多，选择ArrayList

2）如果增删的操作多，选择LinkedList

3）一般来说，在程序中，80%-90%都是查询，因此大部分情况下会选择ArrayList

4）在一个项目中，根据业务灵活选择，也可能一个模块使用的是ArrayList，另一个模块使用了LinkedList.也就是说，要根据业务来进行选择