美文网首页
Java常用集合LinkedList分析

Java常用集合LinkedList分析

作者: 大聪明的博客 | 来源:发表于2022-10-26 20:47 被阅读0次

    LinkedList底层数据结构是一个具有头尾节点的双向链表。双向链表的优点就是通过某个节点访问其前驱和后驱表较方便。缺点是需要额外存储其前驱和后驱的空间。LinkeList链表允许null元素;
    问题一:LinkedList如何初始化

    LinkedList构造函数有两种,无参构造和带集合的构造函数
    1.无参构造,初始化集合大小size=0,初始不用存储任何数据,内存占用低;
     public LinkedList() {
            this.size = 0;
     }
    
    2.带集合的构造函数,创建一个大小和传入集合大小一致的链表,记录头尾节点
     public LinkedList(Collection<? extends E> c) {
            this();
            this.addAll(c);
     }
    3.接着2我们来看下addAll方法,他的参数有index和传入的集合,猜想index应该是传入集合存储开始的地方。
     public boolean addAll(int index, Collection<? extends E> c) {
            //判断这个index是否超过链表有效位置的范围,超出的话会报IndexOutOfBoundsException.
            this.checkPositionIndex(index);
           //返回包含这个集合中所有数据的数组,感觉是个耗时操作
            Object[] a = c.toArray();
          //获取参数集合的长度,是构造之后链表的长度
            int numNew = a.length;
         //参数集合长度为0,说明不需要存储任何数据,就不用做任何事了直接返回。
            if (numNew == 0) {
                return false;
            } else {
          //辅助构造链表
                LinkedList.Node pred;
                LinkedList.Node succ;
            //index = this.size从链表尾部插入
                if (index == this.size) {
                    succ = null;
                    pred = this.last;
                } else {
           //index != this.size从链表中间插入
                    succ = this.node(index);
                    pred = succ.prev;
                }
    
                Object[] var7 = a;
                int var8 = a.length;
            //遍历参数集合的数组,从插入的位置index开始插入
                for(int var9 = 0; var9 < var8; ++var9) {
                    Object o = var7[var9];
                    LinkedList.Node<E> newNode = new LinkedList.Node(pred, o, (LinkedList.Node)null);
                  //插入集合的第一个节点
                    if (pred == null) {
                        this.first = newNode;
                    } else {
                   //上一个节点记录一下当前节点,形成链表
                        pred.next = newNode;
                    }
                    //pred记录当前节点,开始下一个节点的插入
                    pred = newNode;
                }
               //succ =null说明是从链表尾部开始插入的,所以记录一下链表头部,就行了。
                if (succ == null) {
                    this.last = pred;
                } else {
               //相反的不是从链表尾部插入,从第index个插入,index元素排在插入的数据后面,形成新链表。
                    pred.next = succ;
                    succ.prev = pred;
                }
             //记录新的链表长度
                this.size += numNew;
                ++this.modCount;
                return true;
            }
        }
    

    问题二:LinkedList怎么插入数据?
    LinkedList堆插入操作做了相关优化。由于其基于双端链表实现,所以其在头尾插入速度较快,在链表中部插入相对较慢。

        1.头部插入元素,直接通过头节点first插入,头节点变成第二个元素,更新头节点,非常简单。
        private void linkFirst(E e) {
            LinkedList.Node<E> f = this.first;
            LinkedList.Node<E> newNode = new LinkedList.Node((LinkedList.Node)null, e, f);
            this.first = newNode;
            if (f == null) {
                this.last = newNode;
            } else {
                f.prev = newNode;
            }
    
            ++this.size;
            ++this.modCount;
        }
     2.尾部插入元素,直接通过尾节点插入新元素 ,待插入节点变成新的尾节点。
        void linkLast(E e) {
            LinkedList.Node<E> l = this.last;
            LinkedList.Node<E> newNode = new LinkedList.Node(l, e, (LinkedList.Node)null);
            this.last = newNode;
            if (l == null) {
                this.first = newNode;
            } else {
                l.next = newNode;
            }
    
            ++this.size;
            ++this.modCount;
        }
     3.中间插入元素,如果index=链表长度则表示在链表尾部插入数据,否则实在指定元素之前插入元素。
        public void add(int index, E element) {
            this.checkPositionIndex(index);
            if (index == this.size) {
                this.linkLast(element);
            } else {
                this.linkBefore(element, this.node(index));
            }
        }
     4.在看linkBefore之前我看下node方法,这个方法是通过index找到链表中的某个数据。通过以下代码我们可以看到它使用了一次二分查找,提高了一次查找效率,但是随着数据增多这个函数的效率会变得越来越低。
       LinkedList.Node<E> node(int index) {
            LinkedList.Node x;
            int i;
            if (index < this.size >> 1) {
                x = this.first;
                for(i = 0; i < index; ++i) {
                    x = x.next;
                }
                return x;
            } else {
                x = this.last;
                for(i = this.size - 1; i > index; --i) {
                    x = x.prev;
                }
                return x;
            }
        }
     5.接着看下linkBefore方法。找到指定元素就非常好办了,生成新节点,把新节点放在指定元素的前面就可以了。
        void linkBefore(E e, LinkedList.Node<E> succ) {
            LinkedList.Node<E> pred = succ.prev;
            LinkedList.Node<E> newNode = new LinkedList.Node(pred, e, succ);
            succ.prev = newNode;
         //如果succ是头节点,还需要更新头节点指针。
            if (pred == null) {
                this.first = newNode;
            } else {
                pred.next = newNode;
            }
            ++this.size;
            ++this.modCount;
        }
    

    问题三:LinkedList怎么删除元素
    删除节点和增加节点都是通过node方法找到指定元素,然后删除指定节点,链表的基本操作,这里不再赘叙。

    相关文章

      网友评论

          本文标题:Java常用集合LinkedList分析

          本文链接:https://www.haomeiwen.com/subject/kgfndrtx.html