devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JAVA ArrayList，Vector，LinkedList详解（韩顺平）_java linklist vector

作者：AllinToyou | 2024-03-27 04:58:46

赞

踩

java linklist vector

目录

一.ArrayList

1.ArrayList的注意事项

2.ArrayList的底层源码分析

3.代码案例

二.Vector

1.Vector基本介绍

2.源码分析

3.Vector和ArrayList比较

三.LinkedList

1.LinkedList的基本介绍

 2.LinkedList的底层操作

 3.LinkedList的增删改查

4.ArrayList和LinkedList的区别

一.ArrayList

1.ArrayList的注意事项

2.ArrayList的底层源码分析

 

 

3.代码案例

  1. //注意，注意，注意，Idea 默认情况下，Debug 显示的数据是简化后的，如果希望看到完整的数据
  2.         //需要做设置.
  3.         //使用无参构造器创建ArrayList对象
  4.         //ArrayList list = new ArrayList();
  5.         ArrayList list = new ArrayList();
  6.         //使用for给list集合添加 1-10数据
  7.         for (int i = 1; i <= 10; i++) {
  8.             list.add(i);
  9.         }
  10.         //使用for给list集合添加 11-15数据
  11.         for (int i = 11; i <= 15; i++) {
  12.             list.add(i);
  13.         }
  14.         list.add(100);
  15.         list.add(200);
  16.         list.add(null);

二.Vector

1.Vector基本介绍

因为Vector类的操作方法带有synchronized，每一步都要保持线程同步，所以运行速度和ArrayList相比较慢

2.源码分析

  1. //无参构造器
  2.         //有参数的构造
  3.         Vector vector = new Vector(8);
  4.         for (int i = 0; i < 10; i++) {
  5.             vector.add(i);
  6.         }
  7.         vector.add(100);
  8.         System.out.println("vector=" + vector);
  9.         //1. new Vector() 底层
  10.         /*
  11.             public Vector() {
  12.                 this(10);
  13.             }
  14.          补充：如果是  Vector vector = new Vector(8);
  15.             走的方法:
  16.             public Vector(int initialCapacity) {
  17.                 this(initialCapacity, 0);
  18.             }
  19.          2. vector.add(i)
  20.          2.1  //下面这个方法就添加数据到vector集合
  21.             public synchronized boolean add(E e) {
  22.                 modCount++;
  23.                 ensureCapacityHelper(elementCount + 1);
  24.                 elementData[elementCount++] = e;
  25.                 return true;
  26.             }
  27.           2.2  //确定是否需要扩容 条件 ： minCapacity - elementData.length>0
  28.             private void ensureCapacityHelper(int minCapacity) {
  29.                 // overflow-conscious code
  30.                 if (minCapacity - elementData.length > 0)
  31.                     grow(minCapacity);
  32.             }
  33.           2.3 //如果 需要的数组大小 不够用，就扩容 , 扩容的算法
  34.               //newCapacity = oldCapacity + ((capacityIncrement > 0) ?
  35.               //                             capacityIncrement : oldCapacity);
  36.               //就是扩容两倍.
  37.             private void grow(int minCapacity) {
  38.                 // overflow-conscious code
  39.                 int oldCapacity = elementData.length;
  40.                 int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
  41.                                                  capacityIncrement : oldCapacity);
  42.                 if (newCapacity - minCapacity < 0)
  43.                     newCapacity = minCapacity;
  44.                 if (newCapacity - MAX_ARRAY_SIZE > 0)
  45.                     newCapacity = hugeCapacity(minCapacity);
  46.                 elementData = Arrays.copyOf(elementData, newCapacity);
  47.             }
  48.          */

3.Vector和ArrayList比较

三.LinkedList

1.LinkedList的基本介绍

 2.LinkedList的底层操作

代码案例

  1. //定义一个Node 类，Node 对象 表示双向链表的一个结点
  2. class Node {
  3.     public Object item; //真正存放数据
  4.     public Node next; //指向后一个结点
  5.     public Node pre; //指向前一个结点
  6.     public Node(Object name) {
  7.         this.item = name;
  8.     }
  9.     public String toString() {
  10.         return "Node name=" + item;
  11.     }
  12. }
  13.  
  14.  
  15. //模拟一个简单的双向链表
  16.  
  17.         Node jack = new Node("jack");
  18.         Node tom = new Node("tom");
  19.         Node hsp = new Node("老韩");
  20.  
  21.         //连接三个结点，形成双向链表
  22.         //jack -> tom -> hsp
  23.         jack.next = tom;
  24.         tom.next = hsp;
  25.         //hsp -> tom -> jack
  26.         hsp.pre = tom;
  27.         tom.pre = jack;
  28.  
  29.         Node first = jack;//让first引用指向jack,就是双向链表的头结点
  30.         Node last = hsp; //让last引用指向hsp,就是双向链表的尾结点
  31.  
  32.  
  33.         //演示，从头到尾进行遍历
  34.         System.out.println("===从头到尾进行遍历===");
  35.         while (true) {
  36.             if(first == null) {
  37.                 break;
  38.             }
  39.             //输出first 信息
  40.             System.out.println(first);
  41.             first = first.next;
  42.         }
  43.  
  44.         //演示，从尾到头的遍历
  45.         System.out.println("====从尾到头的遍历====");
  46.         while (true) {
  47.             if(last == null) {
  48.                 break;
  49.             }
  50.             //输出last 信息
  51.             System.out.println(last);
  52.             last = last.pre;
  53.         }
  54.  
  55.         //演示链表的添加对象/数据，是多么的方便
  56.         //要求，是在 tom --------- 老韩直接，插入一个对象 smith
  57.  
  58.         //1. 先创建一个 Node 结点，name 就是 smith
  59.         Node smith = new Node("smith");
  60.         //下面就把 smith 加入到双向链表了
  61.         smith.next = hsp;
  62.         smith.pre = tom;
  63.         hsp.pre = smith;
  64.         tom.next = smith;
  65.  
  66.         //让first 再次指向jack
  67.         first = jack;//让first引用指向jack,就是双向链表的头结点
  68.  
  69.         System.out.println("===从头到尾进行遍历===");
  70.         while (true) {
  71.             if(first == null) {
  72.                 break;
  73.             }
  74.             //输出first 信息
  75.             System.out.println(first);
  76.             first = first.next;
  77.         }
  78.  
  79.         last = hsp; //让last 重新指向最后一个结点
  80.         //演示，从尾到头的遍历
  81.         System.out.println("====从尾到头的遍历====");
  82.         while (true) {
  83.             if(last == null) {
  84.                 break;
  85.             }
  86.             //输出last 信息
  87.             System.out.println(last);
  88.             last = last.pre;
  89.         }

 3.LinkedList的增删改查

  1. LinkedList linkedList = new LinkedList();
  2.         linkedList.add(1);
  3.         linkedList.add(2);
  4.         linkedList.add(3);
  5.         System.out.println("linkedList=" + linkedList);
  6.  
  7.         //演示一个删除结点的
  8.         linkedList.remove(); // 这里默认删除的是第一个结点
  9.         //linkedList.remove(2);
  10.  
  11.         System.out.println("linkedList=" + linkedList);
  12.  
  13.         //修改某个结点对象
  14.         linkedList.set(1, 999);
  15.         System.out.println("linkedList=" + linkedList);
  16.  
  17.         //得到某个结点对象
  18.         //get(1) 是得到双向链表的第二个对象
  19.         Object o = linkedList.get(1);
  20.         System.out.println(o);//999
  21.  
  22.         //因为LinkedList 是 实现了List接口, 遍历方式
  23.         System.out.println("===LinkeList遍历迭代器====");
  24.         Iterator iterator = linkedList.iterator();
  25.         while (iterator.hasNext()) {
  26.             Object next =  iterator.next();
  27.             System.out.println("next=" + next);
  28.  
  29.         }
  30.  
  31.         System.out.println("===LinkeList遍历增强for====");
  32.         for (Object o1 : linkedList) {
  33.             System.out.println("o1=" + o1);
  34.         }
  35.         System.out.println("===LinkeList遍历普通for====");
  36.         for (int i = 0; i < linkedList.size(); i++) {
  37.             System.out.println(linkedList.get(i));
  38.         }
  39.  
  40.  
  41.         //老韩源码阅读.
  42.         /* 1. LinkedList linkedList = new LinkedList();
  43.               public LinkedList() {}
  44.            2. 这时 linkeList 的属性 first = null  last = null
  45.            3. 执行 添加
  46.                public boolean add(E e) {
  47.                     linkLast(e);
  48.                     return true;
  49.                 }
  50.             4.将新的结点，加入到双向链表的最后
  51.              void linkLast(E e) {
  52.                 final Node<E> l = last;
  53.                 final Node<E> newNode = new Node<>(l, e, null);
  54.                 last = newNode;
  55.                 if (l == null)
  56.                     first = newNode;
  57.                 else
  58.                     l.next = newNode;
  59.                 size++;
  60.                 modCount++;
  61.             }
  62.  
  63.          */
  64.  
  65.         /*
  66.           老韩读源码 linkedList.remove(); // 这里默认删除的是第一个结点
  67.           1. 执行 removeFirst
  68.             public E remove() {
  69.                 return removeFirst();
  70.             }
  71.          2. 执行
  72.             public E removeFirst() {
  73.                 final Node<E> f = first;
  74.                 if (f == null)
  75.                     throw new NoSuchElementException();
  76.                 return unlinkFirst(f);
  77.             }
  78.           3. 执行 unlinkFirst, 将 f 指向的双向链表的第一个结点拿掉
  79.             private E unlinkFirst(Node<E> f) {
  80.                 // assert f == first && f != null;
  81.                 final E element = f.item;
  82.                 final Node<E> next = f.next;
  83.                 f.item = null;
  84.                 f.next = null; // help GC
  85.                 first = next;
  86.                 if (next == null)
  87.                     last = null;
  88.                 else
  89.                     next.prev = null;
  90.                 size--;
  91.                 modCount++;
  92.                 return element;
  93.             }
  94.          */

4.ArrayList和LinkedList的区别

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/321974
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号