Java数据结构——集合：List接口的常用实现类：Vector，ArrayList，Stack，LinkedList(源码分析)

最新推荐文章于 2022-05-10 16:13:46 发布
最新推荐文章于 2022-05-10 16:13:46 发布
阅读量293 收藏
点赞数
分类专栏： java集合 文章标签： java 数据结构 集合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46369022/article/details/119534824
版权

List实现类

在这里插入图片描述
上篇List接口介绍: https://blog.csdn.net/weixin_46369022/article/details/119516882.

实现类引入

List实现类在List接口基础上有增加了每个实现类独有的方法。
补：
List list = new ArrayList();
list只能可以引用List当中的方法，不能引用ArrayList中的独有方法
ArrayList list=new ArrayList();
list可以引用所有方法

ArrayList:动态数组

物理结构：数组
所以插入和删除操作比较慢，查询比较快
(1)new ArrayList()：
JDK1.8版本：发现内部初始化为了一个长度为0的空数组 DEFAULTCAPACITY_EMPTY_ELEMENTDATA
JDK1.7版本：也是初始化为长度为0的空数组 EMPTY_ELEMENTDATA;
JDK1.6版本：初始化为长度为10的数组

为什么要初始化为空数组呢？
因为开发中，很多时候创建了ArrayList的对象，但是没有装元素，这个时候的话，如果初始化为10的数组，就浪费空间了。

源码：

 public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

(2)add(Object e）
JDK1.8： 第一次添加元素，扩容为长度为10的数组， 如果不够了，再扩容为1.5倍。
源码：

 public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        // DEFAULT_CAPACITY=10   
        }

        ensureExplicitCapacity(minCapacity);
    }
 private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }    
 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //0右移一位还是0;10右移一位是5       
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
            //所以第一次添加数据,扩容为10
            //第二次扩容，扩容为10+5
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

Vector:动态数组

物理结构：数组

（1）new Vector()：数组初始化长度为10的数组，capacityIncrement默认扩容增量是0
源码：

Vector v=new Vector();

  public Vector() {
        this(10);
    }
  public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }
 public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

（2）add(E e)：直接插入元素
默认扩容为原来的2倍
如果你手动指定了capacityIncrement的值，那么可以按照你指定增量进行扩容。

源码：

 public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);//**
        elementData[elementCount++] = e;
        return true;
    }
 private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);//**
    }
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);//**
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

（3）add(index,e)：根据索引插入元素
源码：

 public void add(int index, E element) {
        insertElementAt(element, index);
    }
 public synchronized void insertElementAt(E obj, int index) {
        modCount++;
        if (index > elementCount) {
            throw new ArrayIndexOutOfBoundsException(index
                                                     + " > " + elementCount);
        }
        ensureCapacityHelper(elementCount + 1);
        System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
        elementData[index] = obj;
        elementCount++;
    }

（4）remove(index)：
①计算要移动元素的个数
②如果需要移动，调用System.arraycopy方法进行移动
③elementData[–elementCount] = null;
源码：

 public synchronized E remove(int index) {
        modCount++;
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        E oldValue = elementData(index);

        int numMoved = elementCount - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--elementCount] = null; // Let gc do its work

        return oldValue;
    }

（5）remove(Object obj)
①查找obj的下标
②如果不是-1就调用remove(index)进行删除
源码：

 public boolean remove(Object o) {
        return removeElement(o);
    }
 public synchronized boolean removeElement(Object obj) {
        modCount++;
        int i = indexOf(obj);
        if (i >= 0) {
            removeElementAt(i);
            return true;
        }
        return false;
    }

（6）indexOf(Object obj)
对obj分情况讨论：（1）是null（2）不是null
源码：

 public int indexOf(Object o) {
        return indexOf(o, 0);
    }
 public synchronized int indexOf(Object o, int index) {
        if (o == null) {
            for (int i = index ; i < elementCount ; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = index ; i < elementCount ; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

Stack: 栈

物理结构：数组
先进后出（FILO）或后进先出（LIFO：Last in first out）
Stack是Vector的子类，比Vector多了几个方法，它的后进先出的特征，就是通过调用这几个方法实现的。
(1)Object peek() ：访问当前栈顶元素，但是不拿走栈顶元素
返回size-1位置的元素
源码：

 public synchronized E peek() {
        int     len = size();

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }

(2)Object pop()：弹出栈顶元素
①先peek()返回栈顶元素
②删除size-1位置的元素
源码：

public synchronized E pop() {
        E       obj;
        int     len = size();

        obj = peek();
        removeElementAt(len - 1);

        return obj;
    }

(3)Object push(Object item) ：把元素压入栈顶，等价于add(item)
这里为了更形象化，单独设计了一个push。
把元素添加到[size++]位置
源码：

 public E push(E item) {
        addElement(item);
        return item;
    }

使用示例：

        Stack s = new Stack();
		s.push("1");//push比add可读性更好，功能是一样的
		s.push("2");
		s.add("3");
		s.add("4");
		System.out.println(s.peek());//4
		System.out.println(s.peek());//4
		
		System.out.println(s.pop());//4
		System.out.println(s.pop());//3
		System.out.println(s.pop());//2
		System.out.println(s.pop());//1
//		System.out.println(s.pop());//java.util.EmptyStackException

LinkedList:双向链表

物理结构：链表
LinkedList可以被当做单项列表双向链表、栈、队列、双端队列等数据结构使用，功能强大。但是实际运用开发很少使用

内部有一个结点的类型：
class Node{
                  Object data;
                  Node previous;
                  Node next;
                 }
源码：

 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;
        }
    }

(1)new LinkedList()： 什么也没干，没有创建结点
源码：

public LinkedList() {
    }

(2)add(e)
源码：

public boolean add(E e) {
        linkLast(e);
        return true;
    }
 void linkLast(E e) {
        final Node<E> l = last;
		//新结点的上一节点是刚刚的最后一个结点
		//新结点的下一个结点是null，没有
        final Node<E> newNode = new Node<>(l, e, null);
        //新结点成为了最后一个结点
        last = newNode;
        if (l == null)
            first = newNode;
            //上一节点为空说明链表中没有节点为空，新结点是第一个结点也是最后一个节点
        else
            l.next = newNode;
        size++;
        modCount++;
    }
 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;
        }
    }

(3)remove 删除
源码：

 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;
    }
     E unlink(Node<E> x) {
          //x是要被删除的结点
        // assert x != null;
        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;//被删除结点的上一个结点的next指向被删除结点的下一个结点
            x.prev = null;//把被删除结点与上一个结点断开
        }

        if (next == null) {//被删除结点是最后一个结点
            last = prev;//被删除结点的上一个结点成为了最后一个结点
        } else {//被删除结点不是最后一个结点
            next.prev = prev;//被删除结点的下一个结点的prev指向被删除结点的上一个结点
            x.next = null;//把被删除结点与下一个结点断开
        }

        x.item = null;//把被删除结点的数据清空
        size--;
        modCount++;
        return element;
    }

当做双向链表使用：
(1)E getFirst()
(2)E getLast()
(3)boolean offerFirst(E e) ：添加的第一个
(4)boolean offerLast(E e) :添加到最后一个
(5)int indexOf(Object o) ：从first开始找
(6)int lastIndexOf(Object o) ：从last开始找
(7) E get(int index) 先判断index是靠前还是靠后

当做栈使用
E peek()
E pop()
void push(E e)

当做队列使用
实现了Queue接口
队列：先进先出（FIFO） 一边出

操作失败情况：
在这里插入图片描述

插入队头: add(e)            offer(e)
移除队头: remove()         poll()
检查队头 :element()        peek()

LinkedList list = new LinkedList();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		
		System.out.println(list.poll());//1
		System.out.println(list.poll());//2
		System.out.println(list.poll());//3
		System.out.println(list.poll());//4

当做双端队列使用
实现了Deque（double ended queue（双端队列）的缩写）接口，
两边均能出
在这里插入图片描述

总结

一、 List接口的实现类们：
1、Vector：动态数组
物理结构：数组
2、ArrayList：动态数组
物理结构：数组
3、Stack：栈，它是Vector的子类
物理结构：数组
4、LinkedList：双向链表
物理结构：链表

Vector和ArrayList的区别？都是动态数组有什么不同？

Vector：最早版本的动态数组（旧版），线程安全的（有线程同步的），不够后扩容为原来的2倍（造成空间浪费的可能性比较大），初始容量：10，Vector支持的遍历集合的方式有：（1）foreach（2）Iterator（3）支持旧版的Enumeration迭代器

ArrayList：相对Vector来说新一点（新版），线程不安全的（没有线程同步的），不够后扩容为原来的1.5倍（造成扩容的次数增大），初始容量：10，ArrayList支持的遍历集合的方式有：（1）foreach（2）Iterator

Vector和ArrayList的使用时，为了比较空间浪费，和扩容次数太多，如果能够预估大概的元素个数，那么可以用
ArrayList(int initialCapacity)和Vector(int initialCapacity)直接初始化为一定容量的数组。

数组与ArrayList对比：

1.ArrayList无法存储基本数据类型，需要封装为类，而自动装箱和拆箱有一定的性能消耗。
2.如果数据大小事先已知，并且对数据的操作非常简单，用不到ArrayList提供的大部分方法，可以直接使用数组。
3.多维数组用数组更加直观。

GuochaoHN
关注
专栏目录
Java 集合框架：Vector、Stack 的介绍、使用、原理与源码解析
栗筝i的博客
06-20 3388
Java 集合框架（Java Collections Framework）是 Java 标准库中的一个核心组件，它提供了一套用于处理数据集合的接口和类。作为其中的重要成员，Vector 和 Stack 在特定场景中扮演着关键角色。Vector 是一种同步的动态数组，实现了 List 接口，适用于需要线程安全的场景；而 Stack 是 Vector 的子类，提供了后进先出（LIFO）的数据结构操作。本文将对 Vector 和 Stack 进行全面的介绍，探讨它们的使用方法、工作原理以及源码实现，以帮助开发者深
第十二篇：Java集合详解、ArrayList、Vector、LinkedList、Queue、PriorityQueue、Deque、HashSet、TreeSet
qq_40276626的博客
08-11 521
Java中的集合是我们编程中常用的东西，集合的作用是用来存放对象的，让我更好的管理对象！ Java集合分为三类：List、Queue、Set 1、List List是一个集合，按照元素插入的先后顺序进行排列。 1.1、ArrayList ArrayList的底层是数组，当空间不足的时候，会进行动态扩容。 数组的好处就是随机存储块，但是插入和删除效率不高，删除需要搬运元素，插入有的时候需要动态扩容。 ArrayList是线程不安全的，没有加锁，会出现线程不安全问题 ArrayList需要注意的就是遍历删除指
数据结构 | 链表LinkedList(Java实现)
xxzaa的博客
04-19 497
链表（重要+困难） 对链表这种数据结构的理解 对引用和对象的理解
java stack 接口_JAVA自己实现List接口Stack
weixin_35316354的博客
02-13 205
JAVA自己实现List接口Stack发布时间：2020-07-13 21:32:05来源：51CTO阅读：339作者：kepp007package 集合.Stack;import java.util.Arrays;import java.util.EmptyStackException;import java.util.Vector;public class MyStack {//底层数组默认长...
List接口及其实现类ArrayList、LinkedList、Vector
热门推荐
大哥的叔的博客
01-23 1万+
List接口： java中数组用来存储数据的局限性 List集合中元素有序、可重复，集合中的每个元素都有其对应的顺序索引。 list容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。 JDK API中list接口的实现类常用的有：arraylist、linkedlist和Vector。 List集合里添加了一些根据索引来操作集合元素的方法 Array...
List的三个子类：ArrayList、Vector、LinkedList
元气满满晨
08-23 296
ArraList是List的子类。 删除中多了这个功能： protected void removeRange(int fromIndex, int toIndex) 从这个列表中删除所有索引在 fromIndex （含）和 toIndex之间的元素。 创建并遍历ArrayList集合 1.存储字符串对象 import java.util.Iterator; import j...
List接口的三种实现子类(ArrayList,Vector,LinkedList)
qq_41923771的博客
05-10 744
一:List1:ArrayList  继承于 list   是有序可重复集合的子实现类ArrayList有两种遍历方式,for方法和迭代器public static void main(String[] args) { ArrayList&lt;String&gt; arr = new ArrayList&lt;&gt;(); arr.add("hello"); arr.add("ja...
java8源码-csn-list:ArrayList、LinkedList、Vector、Stack源码分析
06-04
List相关实现类的源码解析（JDK1.8） 2018.9.22- List的架构图 ArrayList 继承关系： ArrayList -> AbstractList 实现 List接口 ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态...
Java stack实现原理_Java集合包（四）——List实现类之LinkedList与Stack原理分析
weixin_30538955的博客
02-16 564
一：LinkedList特征1、LinkedList底层是一个双向链表，可以被当做 堆栈、队列、双端队列 来使用。【能且应该仅被作为 栈、队列、双端队列 来使用！】双向链表，又称为“双向循环链表”，每个数据结点中都有两个引用，分别指向直接后继和直接前驱节点，可以理解为它是一个“首尾相接”的环形链表。从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点，从而可以从任意一个结点...
Java数据结构实现之Stack.zip
最新发布
06-04
- **LinkedList类与List接口**：LinkedList类实现了List接口，可以通过`addFirst()`和`removeFirst()`方法实现栈操作。但相比于ArrayDeque，LinkedList在进行栈操作时效率较低。 ```java LinkedList<Integer> ...
Java用LinkedList实现的Stack
01-04
栈是先进先出的原则，该类实现了栈的移入移除
java集合之List接口的常用实现类、ArrayList、LinkedList、Vector
Q2854542067的博客
05-02 1656
Collection接口的常用方法， 以子类ArrayList实现类来演示: add():添加单个元素 remove():删除指定元素 contains():查找元素是否存在 size():获取元素个数 isEmpty()判断是否为空 clear():清空 addAll():添加多个元素 contaisnAll():查找多个元素是否都存在 removeAll():删除多个元素 如下演示： import java.util.Collection; import java.util.ArrayList; im
linkedlist java 实现,数据结构(LinkedList的java实现)
weixin_32736623的博客
03-16 148
package day10;import java.util.*;public class MyLinkedList implements List{static class Node{public Object data;public Node next;public Node(Object data){this.data=data;}}private Node head;public MyL...
Java集合专题（六）：List接口的实现类之LinkedList
KD_1195的博客
07-14 256
一、LinkedList的基本介绍 1.1、LinkedList底层结构 LinkedList底层实现了双向链表和双端队列特点。 可以添加任意元素（元素可以重复），包括null。 线程不安全，没有实现同步。 1.2、LinkedList底层操作机制 LinkedList底层维护了一个双向链表。 LinkedList中维护了两个属性 first 和 last 分别指向首节点和尾节点。 每个节点（Node对象），里面又维护了prev、next、item三个属性，其中通过 prev 指向前一个
【浅学Java数据结构】简单模拟实现LinkedList
qq_52276036的博客
05-10 217
下面，我们以无头单向链表为例，模拟实现链表： public class MyLinkedList { static class ListNode{ int data; ListNode next; public ListNode(int val){ this.data=val; this.next=null; } } public ListNode head; /
List接口
Xyr的博客
04-28 176
List接口 概述 有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。 Collection将集合划分为两大类：** List集合 Set集合 List接口的特点 有序【存储有序】 可重复 可以存储 null值 部分子集合线程安全，部分不安全 例如 ...
Java 集合 -- List接口实现之ArrayList、LinkedList源码分析
生生不息，则源源不断
11-23 404
什么是java集合 对线性表，链表，哈希表这些常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。因此，我们一般的程序员不必自己开发相关的方法 集合（框架）：java提供了一组对数组、链表数据结构操作的API，这组API即集合；存在于java.util Collection接口的依赖图 这篇文章主要讲List下ArrayList、LinkedList的两个实现。 List接口实现之–ArrayList List 接口的大小可变数组的实现。实现了所有可选列表操
java 集合ArrayList实现类及List接口常用方法及LinkedList和Vector的特点
码农回顾
11-06 1858
java 集合ArrayList实现类及List接口常用方法1.集合结构2.List接口详解3.List实现类之一：ArrayList4.List实现类之二：LinkedList5.List 实现类之三：Vector6.拓展ListIterator接口 1.集合结构 Collection接口 List接口：存储有序的，可重复的元素 ArrayList(主要的实现类)、LinkedList、V...
Java的Stack类实现List接口真的是个笑话吗
weixin_30439067的博客
12-17 104
今天在网上闲逛时看到了这样一个言论，说“Java的Stack类实现List接口的设计是个笑话”。 当然作者这篇文章的重点不是这个，原本我也只是一笑置之，然而看评论里居然还有人附和，说“Java那种Stack的设计作为笑话，差不多可以算公案了”，我就有点不淡定了，为什么、什么时候“作为笑话”的并且“差不多可以算公案”了呢？ 因此我决定写一篇文章来谈谈这个问题。 J...
Java集合框架：List接口详解与实现类比较
常见的List接口实现类有ArrayList、LinkedList、Vector和Stack。 ArrayList和Vector都是基于数组实现的列表，它们的主要区别在于线程安全性和性能。ArrayList是非同步的，因此在多线程环境下如果不进行同步控制，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

GuochaoHN

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值