【JDK8源码】LinkedList集合

最新推荐文章于 2022-08-07 16:05:01 发布
最新推荐文章于 2022-08-07 16:05:01 发布
阅读量3.8k 收藏 26
点赞数 19
文章标签： java linkedlist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43988801/article/details/114694721
版权

【JDK8源码】LinkedList集合

LinkedList特性

  • 双向链表，增删快，随机访问慢（相对ArrayList）
  • 泛型类，可存储任意类型
  • 离散空间，不需要主动扩容

LinkedList数据结构

 private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

LinkedList底层的数据结构是双向链表（jdk1.7之前是双向循环链表），即为双向数据链结构，每一个节点存放了一个Node，Node又有三个属性，item：实际存入的元素，next：下一个结节点的引用，prev：前一个节点的引用，各个Node之间手拉手构成了一个双向链表。

源码分析

层次结构

在这里插入图片描述

  • LinkedList被声明为LinkedList<E>，表示LinkedList可以存储任意类型
  • AbstractSequentialList：继承自AbstractList，Abstract List提供了随机访问，ArrayList就是继承于AbsctractList，而AbstractSequentialList实现了List的一些主要方法，比如set(),get(),remove(),降低了接口的复杂度，提供的是顺序访问，实现的所有方法都是调用的 ListIterator 相关方法。
  • List：一个元素存取有序的集合，实现List接口能进行队列操作。
  • Deque：双端队列，继承自Queue，表示LinkedList可以作为双端队列使用，可以从列表的两端进行插入和删除操作。
  • Cloneable：实现该接口后可使用OBject.Clone()方法，否则会抛出异常
  • Serializable：序列化接口，表示该类可以被序列化。

属性


    //链表元素节点的个数
    transient int size = 0;
    //指向链表的第一个元素
    transient Node<E> first;
    //指向链表的最后一个元素
    transient Node<E> last;
    
    //内部类Node
    private static class Node<E> {
        //当前存储的元素
        E item;
        //当前元素的下一个元素的引用
        Node<E> next;
        //当前元素的下一个元素的引用
        Node<E> prev;
        //构造方法
        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

构造函数

    //无参构造函数
    public LinkedList() {
    }
    //有参构造方法，将参数集合添加到创建的集合中
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

多处调用的方法

   //校验传入的index是否在范围内
      private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

   //根据index查找集合中的某个节点，因为需要遍历查找，不能随机访问，所以效率比Array List低
       Node<E> node(int index) {
        // assert isElementIndex(index);
        //如果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;
        }
    }

常用方法

  • add
  1. addFirst(E e)：将元素插入到集合的第一个节点
    public void addFirst(E e) {
       linkFirst(e);
    }
    private void linkFirst(E e) {
      //先取出原本在链表first的节点
      final Node<E> f = first;
      //创建一个新的节点，上一个节点引用为null，存储元素为e，下一个节点的引用为之前的Frist节点f
      final Node<E> newNode = new Node<>(null, e, f);
      //将新的节点设置为frist节点
      first = newNode;
      //如果之前的frist节点为空
      if (f == null)
      //则把当前的节点设置为last节点
          last = newNode;
      else
      //否则把原Frist节点的prev设置为当前的节点
          f.prev = newNode;
       //集合长度增加
      size++;
      modCount++;
  }
  1. addLast(E e)和add(E e),都是将元素插入到集合的末尾
  public void addLast(E e) {
      linkLast(e);
  }
  
  void linkLast(E e) {
      //创建一个节点保存当前集合的最后一个节点
      final Node<E> l = last;
      //创建一个前节点为当前集合的最后一个节点，后节点为null，节点值为node的节点
      final Node<E> newNode = new Node<>(l, e, null);
      //将当前集合的last设置为新的节点
      last = newNode;
      //如果原集合的最后一个节点为空，则把当前节点设置为集合的第一个节点
      if (l == null)
          first = newNode;
      else
      //否则把原集合最后一个节点的下一个节点引用设置为当前节点
          l.next = newNode;
        //集合长度增加
      size++;
      modCount++;
  }
  1. add(int index, E element):将元素添加到集合的指定位置
   public void add(int index, E element) {
   //首先判断index是否在集合长度内，如果没有则抛出异常
      checkPositionIndex(index);

   //如果index刚好等于集合的长度值，则直接调用插入到最末尾的方法
      if (index == size)
          linkLast(element);
      else
      //否则获取index处的元素，并调用插入到到指定位置的方法
          linkBefore(element, node(index));
  }

   //将元素添加到最末尾，上面已经说过
    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++;
  }
  //传入的参数为当前需要添加的元素和原index处的节点
    void linkBefore(E e, Node<E> succ) {
      // assert succ != null;
      //将原来index节点的前节点引用保存到新的节点
      final Node<E> pred = succ.prev;
      //创建一个新的节点，前节点引用为pred，当前元素值为e，下节点引用为succ
      final Node<E> newNode = new Node<>(pred, e, succ);
      //将原index处的节点的前节点引用设置为当前添加的元素
      succ.prev = newNode;
      if (pred == null)
      //如果原index处的节点的prev值为空，则将当前元素设置为首节点
          first = newNode;
      else
      //否则将原index处的节点的next设置为当前添加的节点
          pred.next = newNode;
          //数组长度增加
      size++;
      modCount++;
  }
  1. addAll(int index, Collection<? extends E> c)：将一个集合添加到集合的指定位置
 public boolean addAll(int index, Collection<? extends E> c) {
 //判断index的值是否超出集合的长度
       checkPositionIndex(index);

       //将集合元素转换为数组
       Object[] a = c.toArray();
       int numNew = a.length;
       //如果数组长度为0直接返回失败
       if (numNew == 0)
           return false;
       //创建两个节点，一个是index位置节点的前节点，一个是index位置的节点
       Node<E> pred, succ;
       //如果index==集合长度，说明是添加到最末尾，将集合前节点设置为最后一个节点
       if (index == size) {
           succ = null;
           pred = last;
       } else {
       //否则取出当前index位置的节点和index位置节点的前节点
           succ = node(index);
           pred = succ.prev;
       }
       //循环遍历要添加的元素数组，将元素依次添加到prve的后面
  for (Object o : a) {
           @SuppressWarnings("unchecked") E e = (E) o;
           Node<E> newNode = new Node<>(pred, e, null);
           if (pred == null)//判断原index位置的节点是不是首节点
           //如果是，就将首节点设置成新的节点
               first = newNode;
           else
           //否则将原index节点的前节点的后节点设置为当前的节点
               pred.next = newNode;
           pred = newNode;
       }
      //判断原集合是否为空，如果是空直接把pred设置成尾节点
       if (succ == null) {
           last = pred;
       } else {
       //否则把pred添加到succ的前面
           pred.next = succ;
           succ.prev = pred;
       }

       size += numNew;
       modCount++;
       return true;
   }
  1. addAll(Collection<? extends E> c)：将一个集合添加到该集合中
 //内部调用的还是addAll(int index,Collecction<? extends E> c)方法
  //将index值设置为当前集合的最后一个元素
 public boolean addAll(Collection<? extends E> c) {
     return addAll(size, c);
 }
  • remove
  1. removeFirst()：删除集合的首节点
       //元素进入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;
        //保存要删除节点的item值
        final E element = f.item;
        //新建一个next等于当前要删除节点的next
        final Node<E> next = f.next;
        //把首节点的item值和next值设置为null
        f.item = null;
        f.next = null; // help GC
        //把首节点设置为原首节点的next节点
        first = next;
        //如果next==null,则把last节点也设置为空
        if (next == null)
            last = null;
        else
        //否则把原来第二个节点的前节点设置为null，表示原来的第二个节点变为首节点
            next.prev = null;
        //集合长度自减1
        size--;
        modCount++;
        //返回原集合的首节点的值
        return element;
    }
  1. removeLast()：删除集合的尾节点
   //当元素进入removeLast方法
   public E removeLast() {
   //声明常量保存要删除的节点
      final Node<E> l = last;
      if (l == null)
      //如果节点为空，抛出异常
          throw new NoSuchElementException();
          //否则进入删除最后一个节点的方法
      return unlinkLast(l);
    }
    
     private E unlinkLast(Node<E> l) {
      //保存节点中的元素值
      final E element = l.item;
      //保存节点的前一个节点
      final Node<E> prev = l.prev;
      //将节点的item和prev设置为null
      l.item = null;
      l.prev = null; // help GC
      //把尾节点设置为当前删除节点的前一个节点
      last = prev;
      //如果前节点为空，则把首节点也设置为空
      if (prev == null)
          first = null;
      else
      //把原节点的前一个节点的next设置为null，标志为最后一个节点
          prev.next = null;
          //集合长度自减
      size--;
      modCount++;
      //返回原节点的值
      return element;
  }
  1. remove(Object o)：删除指定元素

 public boolean remove(Object o) {
 //判断元素是否为空
      if (o == null) {
      //如果为空，遍历找出第一个item为空的节点
          for (Node<E> x = first; x != null; x = x.next) {
              if (x.item == null) {
              //进入删除方法
                  unlink(x);
                  return true;
              }
          }
      } else {
      //如果不为空，匹配第一个item等于o的节点
          for (Node<E> x = first; x != null; x = x.next) {
              if (o.equals(x.item)) {
              //进入删除方法
                  unlink(x);
                  return true;
              }
          }
      }
      return false;
  }
  E unlink(Node<E> x) {
      // 取出删除节点的item、next、prev
      final E element = x.item;
      final Node<E> next = x.next;
      final Node<E> prev = x.prev;

      //如果原节点的前节点为空，说明是首节点
      if (prev == null) {
      //把原节点的下一个节点设置为首节点
          first = next;
      } else {
      //否则把原节点的上一个节点的next设置为原节点的next
          prev.next = next;
          //把原节点的prev设置为空
          x.prev = null;
      }
     //如果原节点的后节点为空，说明是尾节点
      if (next == null) {
      //把原节点的上一个节点设置为尾节点
          last = prev;
      } else {
      //否则把原节点的下一个节点的prev设置为原节点的prev，把原节点的next设置为空
          next.prev = prev;
          x.next = null;
      }

      x.item = null;
      size--;
      modCount++;
      return element;
  }
  1. remove(int index)
  //元素进入该方法，首先判断index是否超过了集合的长度，如果超过就抛出异常
  //实际与remove(Object o)方法一样，只是先调用了node方法，通过index取到节点
  //再调用unlink接触链式绑定，删除节点
  public E remove(int index) {
      checkElementIndex(index);
      return unlink(node(index));
  }  
  
   E unlink(Node<E> x) {
      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;
  }
  • set(int index, E element)：用指定的元素替换列表中指定位置的元素
   public E set(int index, E element) {
     //元素进入set方法，首先判断index的值是否超出了集合的长度，如果超出了就抛出异常
       checkElementIndex(index);
       //调用node方法，获取要替换的元素
       Node<E> x = node(index);
       //取出要替换的元素
       E oldVal = x.item;
       //替换为新的元素
       x.item = element;
       //返回指定位置要替换的旧的元素
       return oldVal;
   }
  • get
  • getFirst()：获取集合的第一个元素
  public E getFirst() {
     //获取集合的第一个节点
      final Node<E> f = first;
      //如果为空，抛出异常
      if (f == null)
          throw new NoSuchElementException();
         //否则返回节点中的item值
      return f.item;
  }
  • getLast()：获取集合中的最后一个元素
  public E getLast() {
     //获取集合的最后一个节点
      final Node<E> l = last;
      //如果节点为空，抛出异常
      if (l == null)
          throw new NoSuchElementException();
         //否则返回节点的item值
      return l.item;
  }
  • get(int index):根据索引值获取元素
  public E get(int index) {
  //判断index是否超出了集合的长度，如果超出则抛出异常
      checkElementIndex(index);
      //否则调用node方法返回指定位置节点的item值
      return node(index).item;
  }
  • indexOf(Object o)：判断元素是否存在，存在则返回索引值，不存在返回-1
 public int indexOf(Object o) {
        int index = 0;
        //判断o是否为空
        if (o == null) {
        //如果为空，遍历匹配第一个为空的值
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null)
                    return index;
                //匹配到了，返回节点位置
                index++;
            }
        } else {
        //如果不为空，遍历匹配第一个值与o相同的值
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                //匹配到了，返回节点位置
                    return index;
                index++;
            }
        }
        //如果没有匹配到，返回-1
        return -1;
    }

遍历集合

  • 使用普通循环
  List<String> list=new LinkedList<String>();
       list.add("123");
       list.add("12345");
       list.add("123");
       list.add("12345");
       //手写for循环
       for (int i=0;i<list.size();i++){
           //调用LinkedList的get(int index)方法
           list.get(i);
       }
       

 //get方法的内部还是使用node方法循环遍历取到元素的
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
    //使用node方法遍历，是通过next或者prev获取到前后的节点引用
    //假设需要循环取到index=3和index=4的值
    //那么第一轮循环要遍历0-3的值，第二轮循环还要遍历0-4的值
    //虽然有把集合一分为二，但是假设数据量多的时侯，循环遍历的时间还是不短的
    Node<E> node(int 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;
        }
    }
  • 使用迭代器
       List<String> list=new LinkedList<String>();
       list.add("123");
       list.add("12345");
       list.add("123");
       list.add("12345");

       //使用迭代器进行循环
       //调用listIterator()方法初始化一个迭代器
       Iterator<String> l=list.listIterator();
       //遍历循环
       while (l.hasNext()){
       System.out.println(l.next());
       }


   private class ListItr implements ListIterator<E> {
   //表示最后一次访问过的对象
     private Node<E> lastReturned;
     //表示下一次调用next方法时返回的元素
       private Node<E> next;
       //表示下一次调用niex()方法时返回的元素的下标
       private int nextIndex;
       //expectedModCount是ListItr持有的修改次数，modCount是LinkedList持有的修改次数
       //为了防止多线程下同时修改集合的元素
       private int expectedModCount = modCount;
       //初始化迭代器，如果参数为空表示从0开始循环
       //通过node(index)方法将下一次调用next()方法时要返回的节点以及节点下标存储在next变量内
       ListItr(int index) {
       //如果index已经等于集合的长度，则返回null
           next = (index == size) ? null : node(index);
           nextIndex = index;
       }
       //用于循环时判断是否还有下一个节点
       public boolean hasNext() {
           return nextIndex < size;
       }

       public E next() {
          //判断内外两个修改次数是否一致，不一致则抛出异常
           checkForComodification();
           //判断是否还有下一个节点，如果没有也抛出异常
           if (!hasNext())
               throw new NoSuchElementException();
           //迭代器循环遍历时不需要每次从头开始的关键代码在此
           //每次在调用next()方法的时候，已经将下一次调用时需要返回的值记录下来了
           //所以在循环取下一个值的时候不需要再从第一个节点next到需要的节点，而是直接返回记录下来的next节点
           //将最后一次访问的元素存储到lastReturned变量中
           lastReturned = next;
           //设置下一次访问时要返回的元素
           next = next.next;
           //下标自增
           nextIndex++;
           //返回当前的节点值
           return lastReturned.item;
       }
   }
Judy-zqj
关注
  • 19
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 14
    评论
jdk1.6 源码jdk1.6 源码
06-07
7. **集合框架**：JDK 1.6的`java.util`包包含了各种集合实现，如ArrayList、LinkedList、HashMap等。源码分析可以揭示它们的内部结构和操作算法，这对于理解性能和选择合适的集合类型很有帮助。 8. **网络编程**：...
LinkedList的底层实现原理（JDK8）
ACGkaka的博客
06-26 246
LinkedList的底层实现原理（JDK8）
从JDK8源码中看ArrayList和LinkedList的区别
qq_52173163的博客
08-07 326
ArrayList和LinkedList的区别是面试中经常会被问到的一点，但是如果只看八股文去背诵着两者的区别，就不会有深刻的认识。本篇文章从数据结构以及JDK8源码的角度来分析这两者的区别，希望给读者带来更多的思考。 在看ArrayList和LinkedList的区别之前我们先来看一下数据结构的相关知识。 线性表是最常用的一种数据结构，简单来说线性表是n个数据元素的有限序列。线性表有两种实现方式，一种是顺序实现，一种是链式实现。顺序实现是用一组地址连续的存储单元依次存储线性表的数据元素。 链式实现用一组任
面试必备：LinkedList源码解析（JDK8）
热门推荐
zxt0601的博客
08-17 1万+
概述本篇是Java集合类解析的第二篇，上一篇[面试必备：ArrayList源码解析（JDK8）]里，我们唠了ArrayList，今儿来继续说LinkedList.面试中，这兄弟俩也经常会拿来比较。它们两可以说是List接口的两种不同的实现，ArrayList的增删效率低，但是改查效率高。 而LinkedList正好相反，增删由于不需要移动底层数据，其底层是链表实现的，所以效率较高。 而改和查，都
JDK8中LinkedList的工作原理剖析
三劫散仙
03-06 195
LinkedList虽然在日常开发中使用频率并不是很多，但作为一种和数组有别的数据结构，了解它的底层实现还是很有必要的。 在这之前我们先来复习下ArrayList的优缺点，ArrayList基于数组的动态管理实现的，数组在内存中是一块连续的存储地址并且数组的查询和遍历是非常快的；缺点在于在添加和删除元素时，需要大幅度拷贝和移动数据，还要考虑是否需要扩容操作，所以效率比较低。 正是由...
[面试源码] jdk8 之 LinkedList解析
荼白
07-19 253
概述 LinkedList 是线程不安全的，允许元素为null的双向链表。 其底层数据结构是链表，它实现List, Deque, Cloneable, java.io.Serializable接口，因为实现了Deque接口,所以也可以作为一个双端队列。和ArrayList相比较因为没有实现RandomAccess所以它以下标随机访问数据比较慢。 因为底层是链表实现的，所以在增加和删除时只修改指针就可以了，所以时间效率高，也不需要扩容，所以空间效率比arraylist（数组实现）高。 缺点就是当随机访问元素时
jdk源码 jdk源码
02-01
Java Development Kit (JDK) 源码是学习和理解Java平台核心机制的关键资源。...通过深入阅读JDK源码，开发者不仅可以增强对Java语言特性的理解，还能提高解决实际问题的能力，这对于成为一名优秀的Java开发者至关重要。
jdk src 源码 压缩包提取
02-16
Java JDK源码是Java开发人员深入理解平台内部工作原理的重要资源。这个压缩包包含了JDK的源代码，供开发者学习和研究。通过下载并解压缩这个文件，你可以直接查看到Java标准库的各种类和方法的实现细节。 源码分析...
jdk1.7源码包含util
01-30
通过阅读和分析JDK 1.7的源码，我们可以深入了解这些类和接口的实现细节，这对于优化代码性能、排查问题以及设计自己的数据结构和算法都有很大帮助。同时，这也是学习Java语言和提升编程能力的重要途径。
jdk1.8 sun源码
09-13
6. **集合框架**：`java.util`包中的集合类，如ArrayList、HashMap、LinkedList等，其内部实现细节对于理解数据结构和算法有很大帮助。 7. **I/O流**：`java.io`和`java.nio`包提供了丰富的输入/输出流接口和类，...
尚硅谷-深入java8的集合2：LinkedList的实现原理.pdf
07-05
本教程特点： 1.更适合零基础学员： ·自Java语言起源始，循序渐进，知识点剖析细致且每章配备大量随堂练习，让你步步为营，学得透彻、练得明白 ·拒绝晦涩难懂的呆板教学，宋老师语言生动幽默，举例形象生动深入浅出，迅速让你把握问题本质，四两拨千斤 2.课程内容推陈出新： ·基于JDK 11，将Java8、Java9、Java10、Java11新特性一网打尽 ·课程中，Eclipse和IDEA这两种企业一线开发环境都使用到了 3.技术讲解更深入、更全面： ·课程共30天，715个知识视频小节，涉及主流Java使用的方方面面，全而不冗余 ·全程内容涵盖数据结构、设计模式、JVM内存结构等深度技术 ·企业级笔试面试题目深入源码级讲解，拒绝死记硬背 4.代码量更大、案例更丰富、更贴近实战： ·Java语言基础阶段：12720行代码，Java语言高级阶段：11684行代码 ·课堂实战项目3套，课后实战项目2套 ·近百道企业面试真题精讲精练、极具实战性
LinkedList源码分析（基于JDK8）
Fighter168的专栏
03-12 5741
LinkedList简介 LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。 LinkedList 实现 List 接口，能对它进行队列操作。 LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。 LinkedList 实现了Cloneable接口，即覆盖了函数clon
jdk1.8 LinkedList
fanfan999的博客
08-30 366
JDK1.8 LinkedList源码 构造方法 空参就是创建一个空的链表,可以将一个集合作为参数传进来,此时会新建一个空链表,然后把集合中的元素都拷贝过来 add()方法 第二句new Node()就表示创建一个新节点,节点元素为e,前继节点为l,后继节点为null add()方法的返回值为布尔类型,只会返回true; 添加的过程就是调用linkLast方法的过程,其中它会先将最后一个...
Java集合 LinkedList 底层详解
奔跑的蜗牛
05-13 2911
Java集合的LinkedList底层详解 前一篇文章，已经讲过ArrayList的底层实现原理，今天学习LinkedList底层实现原理。 LinkedList类是List接口的实现类，它是一个集合，可以根据索引来随机的访问集合中的元素，还实现了Deque接口，它还是一个队列，可以当成双端队列来使用。虽然LinkedList是一个List集合，但是它的实现方式和ArrayList是完全不同的，A...
Java之使用Integer类中的parseInt()方法将字符串转换为基本数据类型
weixin_34185512的博客
08-25 1244
import java.util.*; public class SystemInfo {     public static void main(String[] args)     {         Properties  sp = System.getProperties();         Enumeration e = sp.propertyNames();         whil...
JAVA8之LinkedList
piccasi的专栏
05-23 338
@[TOC]JAVA8之LinkedList 类继承层次 底层数据结构 双链表 节点结构如下： private static class Node<E> { E item; Node<E> next; Node<E> prev; Node(Node<E> prev, E element, Node<E> next) { this.item = ele
LinkedList源码分析
weixin_30692143的博客
09-02 146
前言：LinkedList的底层数据结构是双向链表，下面具体分析其实现原理。 注：本文jdk源码版本为jdk1.8.0_172 1..LinkedList介绍 LinkedList继承于AbstractSequentialList的双向链表，实现List接口，因此也可以对其进行队列操作，它也实现了Deque接口，所以LinkedList也可当做双端队列使用，还有LinkedLi...
JAVA集合之LinkedList源码解析(JDK8)
qq_18581221的博客
04-18 3077
文章目录前言源码解析LinkedList类LinkedList属性LinkedList构造器LinkedList存储元素内部类LinkedList主要方法LinkedList优缺点总结 前言         LinkedList和ArrayList有很大程度的相似，但却各有千秋，LinkedList没有容量的限制（只要...
JDK8 LinkedList源码解读
ScholarTang的博客
06-02 354
LinkedList源码分析 1.链表介绍 链表是一种物理存储单元上非连续、非顺序的存储结构，数组元素的逻辑顺序是通过链表中的指针连接次序实现的。链表由一系列节点（链表中每一个元素都称为节点）组成，节点可以在运行时动态生成。每一个节点都包括两部分：一个是存储数据元素的数据域、另一个是存储下一个节点地址的指针域。 双向链表是链表的一种，由节点组成，每一个数据节点中都有两个指针，分别指向直接后继和直接前驱。 2.LinkedList的底层实现 LinkedList是基于双向链表实现的; 源码 1.构造方法
Java装逼指南.pdf
最新发布
03-22
这份文档并非初级教程，而是侧重于查漏补缺，帮助读者深化理解Java的基础语法、JDK源码解析、并发与多线程、I/O操作、设计模式、常用框架、数据库技术、数据结构与算法、JVM原理、Web开发、Linux系统管理、Redis缓存...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值