Vector 和 Stack 的底层源码分析

最新推荐文章于 2024-08-03 17:05:14 发布
最新推荐文章于 2024-08-03 17:05:14 发布
阅读量290 收藏 7
点赞数 3
文章标签： java list 底层分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57463864/article/details/139098105
版权

Vector 和 Stack 的底层源码分析

 

Vector的底层源码：

研究思路：
       1.研究继承关系
       2.研究属性
       3.理解创建集合的过程 – 构造方法的底层原理
       4.研究添加元素的过程

场景：

public static void main(String[] args) {
		//扩容机制是：数组原来长度 + 容量增量
		//Vector<String> v = new Vector<>(10,5);
    
    	//扩容机制是：数组原来长度的2倍
        Vector<String> v = new Vector<>();

        v.add("aaa");
        v.add("bbb");
        v.add("ccc");
        v.add("ddd");
		
	}
}

 

1.研究继承关系

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
	//外部操作数（计算添加和删除的次数）
    protected transient int modCount = 0;//4
    
    protected AbstractList() {
    }
}

 

2.研究属性

	 //数组最大容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
    //数据容器 
    protected Object[] elementData;
    //元素个数
    protected int elementCount;
    //容量增量
    protected int capacityIncrement;

 

3.理解创建集合的过程 – 构造方法的底层原理

    public Vector() {
            this(10);
        }
    
    //initialCapacity - 10
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }
    
    //initialCapacity - 10
    //capacityIncrement - 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;
    }

 

4.研究添加元素的过程

   	//添加方法
	public synchronized boolean add(E e) {
        modCount++;
        //判断数组容器是否扩容
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
    
    //minCapacity - 11
	//判断是否扩容方法
    private void ensureCapacityHelper(int minCapacity) {
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    //minCapacity - 11
	//扩容方法
    private void grow(int minCapacity) {
        // oldCapacity - 10
        int oldCapacity = elementData.length;
        // newCapacity = 10 + 10
        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);
    }
    

	//超大容量
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

 

5. Vector分析的总代码

public class Vector<E> extends AbstractList<E> implements List<E>{
    
    //数组最大容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
    //数据容器 - ["aaa","bbb","ccc","ddd",null,null,null,null,null,null]
    protected Object[] elementData;//new Object[10];
    //元素个数
    protected int elementCount;//4
    //容量增量
    protected int capacityIncrement;//0
    
    public Vector() {
        this(10);
    }
    
    //initialCapacity - 10
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }
    
    //initialCapacity - 10
    //capacityIncrement - 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;
    }
    
    // e - "ddd"
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
    
    //minCapacity - 11
    private void ensureCapacityHelper(int minCapacity) {
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    //minCapacity - 11
    private void grow(int minCapacity) {
        // oldCapacity - 10
        int oldCapacity = elementData.length;
        // newCapacity = 10 + 10
        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);
    }
    
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
}

 

6.深究

1.研究删除集合的过程
2.研究遍历集合的过程

 

7.面试题

Vector的底层数据结构是什么？

       Object类型的一维数组

Vector的使用场景是什么？

       在多线程下使用，因为Vector方法上加锁，是线程安全的集合

Vector的扩容机制是什么？

       如果容量增量大于0，扩容机制是：数组原来长度 + 容量增量

       如果容量增量小于等于0，扩容机制是：数组原来长度的2倍

 
 

Stack的底层源码：

研究思路：
       1.研究继承关系
       2.研究属性
       3.理解创建集合的过程 – 构造方法的底层原理
       4.研究添加元素的过程

场景：

public static void main(String[] args) {
    
    	Stack<String> stack = new Stack<>();

        v.add("aaa");
        v.add("bbb");
        v.add("ccc");
        v.add("ddd");
		
	}
}

 

1.研究继承关系

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
	//外部操作数（记录添加和删除的次数）
    protected transient int modCount = 0;
}


public class Vector<E> extends AbstractList<E> implements List<E>{
    
    public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = obj;
    }
    
    public synchronized int size() {
        return elementCount;
    }
    
    public synchronized E elementAt(int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
        }

        return elementData(index);
    }
}

 

2.研究属性

 

3.理解创建集合的过程 – 构造方法的底层原理

public Stack() {
    }

 

4.研究添加元素的过程

 public E push(E item) {
        addElement(item);//调用父类的addElement() -- 添加元素
        return item;
    }

 

5. Stack分析的总代码

public class Stack<E> extends Vector<E> {
	
    public Stack() {
    }
    
    //item - "aaa"
    public E push(E item) {
        addElement(item);//调用父类的addElement() -- 添加元素
        return item;
    }
    
    //删除栈顶元素
    public synchronized E pop() {
        E obj;
        int len = size();//调用父类的size() -- 获取元素个数

        obj = peek();//获取栈顶元素
        
        //len - 1 表示最后一个元素的下标
        removeElementAt(len - 1);//调用父类的removeElementAt() -- 删除最后一个元素

        return obj;
    }
    
    public synchronized E peek() {
        int len = size();//调用父类的size() -- 获取元素个数

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);//调用父类的elementAt() -- 获取指定下标上的元素
    }

}

注意：

  1. 研究Stack底层是如何实现栈的数据结构。
  2. Stack底层所有的功能都依赖于父类Vector的方法，只不过Stack有自己的逻辑（栈）。
欧阳大帅哥
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java集合Stack源码详解
08-27
源码分析： Stack的源码简洁明了，主要方法如push、pop、peek等都是直接调用Vector类中的相应方法。例如，`push()`实际上是调用`addElement()`向数组的末尾添加元素，而`pop()`则是调用`removeElementAt()`移除数组...
map queue stack
05-28
这些数据结构的源码分析对于理解其内部工作原理至关重要，尤其是对于优化算法和提高代码效率。通过阅读和学习源码，我们可以了解到如何实现这些数据结构以及如何有效地操作它们。 在实际开发中，工具库如`utils`...
ArrayList/Vector/Stack底层分析
Ryze
10-06 211
ArrayList ArrayList 实现于 List、RandomAccess 接口。可以插入空数据null，也支持随机访问。 List接口中的特有的增删改查： 增：add( int index , Object element ) 删：remove( int index ) //注意是下标而不是元素 改：set( int index , Object newElement ) 查：get(...
03_Vector和Stack
爱喝咖啡的程序员的博客
07-03 637
03_Vector和Stack一. 基本原理和优缺点二. 源码分析2.1 push2.2 pop三. 总结 一. 基本原理和优缺点 Stack继承了Vector，Vector底层还是一个List，也就是基于数组来实现的，所以ArrayList有的优点，比如获取元素的速度快，随机读，它都有，与此相对的，ArrayList的缺点，比如从中间插入一个元素，从中间删除一个元素，Stack也存在。 但是呢，Stack使用最多的方法就是push和pop，换句话说，Stack的作者并非希望我们把使用ArrayList的那
Vector、Stack源码分析
shinerio的博客
04-03 141
Vector、Stack源码分析 Vector Vector继承自AbstractList，实现了List,RandowAccess,Cloneable,Serializable接口，是ArrayList在多线程下的替代选择。Vector大部分方法都与ArrayList实现相同，不同的是需要同步的方法都使用了synchronized 关键词进行修饰，所有是同步的。 /** 按索引顺...
Vector和Stack分析
IceMimosa的专栏
12-30 1097
1. Vector与ArrayList作为底层都是采用动态数组作为实现基础的类，Vector和ArrayList在很多方面都是大同小异的。在阅读之前本文之前可以先阅读ArrayList的源码解析，然后Vector基本就一目了然了。 说下他们的主要区别： 1. Vector里面的方法都是同步的，线程安全的。 2. Vector的扩容大小与ArrayList不同，Vector1.6
Vector和Stack源码分析/List集合的总结
weixin_33949359的博客
11-21 72
　　　　序言 　　　　　　　　这篇文章算是在这list接口下的集合的最后一篇了，前面ArrayList、LinkedList都已经讲解完了，剩下就Vector和Vector的子类Stack啦。继续努力。一步一个脚印， 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　--WH 扩展 　　　　学习vector，需要一些多线程的知识，这里比...
Vector & Stack深入源码
小咸白鱼的博客
04-03 122
Java容器专栏： Java容器源码详细解析（面试知识点） 因为部分内容可能已经在本专栏前面的文章提及到，这里只是简单说明，所以建议先看看： ArrayList LinkedList Vector Vector这个类现在已经不常用了，快被遗弃了。 （一）Vector底层数据结构 和ArrayList一样，底层都是Object动态数组。（向量队列） （二）Vector继承和实...
深入理解 LinkedList 及底层源码分析
好好学java
05-03 1097
1、继承树结构：2、LinkedList 定义LinkedList继承了 AbstractSequentialList 类，实现了 List 接口、Deque 接口、Cloneable 接口、java.io.Serializable 接口。LinkedList实现了 List 接口，即能对它进行队列操作，提供了相关的添加、删除、修改、遍历等功能。LinkedList实现了 Deque 接口，即能将 LinkedList 当作双端队列使用。LinkedList。
Vector扩容机制源码分析
天涯~的博客
09-12 601
再来稍微聊一下Vector的特点。 继承树 Vector继承树如下图： 特点 （1）允许null值 （2）底层使用动态对象数组Object[] elementData （3）默认初始容量是10 （4）线程安全，通过synchronized锁得以保证 （5）fail-fast机制 ...
C++ STL Queue,Stack底层实现分析
qq_51845557的博客
10-17 2085
C++容器适配器(Adapter) stack与queue是非常常用的STL容器.队列与栈也是比较基础的数据结构类型.今天我们来实现一个stack与一个queue. 基本结构 stack也就是栈,遵循的是先进后出原则.queue也就是队列,遵循的是先进先出的原则. 作为基本数据结构的队列与栈没有什么难点. 此外,stack与queue不能遍历,不能随机访问,不能查询中间结点,不能插入中间结点,只能做与其性质对应的两端结点的操作. STL...
stack类模板源代码
04-26
比如，你可以结合`vector`和`stack`来实现一个简单的LRU缓存淘汰策略，或者与`queue`结合处理优先级队列问题。 总的来说，理解`stack`类模板的源代码对于提升C++编程技能至关重要。通过掌握其工作原理，你可以在...
STL标准模板库源码
08-22
5. 容器适配器（Container Adapters）：如`stack`、`queue`和`priority_queue`，它们基于现有的容器提供特定的行为，比如后进先出（LIFO）的栈和先进先出（FIFO）的队列。 6. 动态内存管理（ allocators）：负责...
stl源码剖析.zip
06-09
这些算法通常比手写实现更高效且错误率低，源码分析能帮助我们了解其优化技巧和底层实现。 4. **函数对象（Functors）**：函数对象是具有operator()的类，用于封装函数调用。它们在算法中作为参数传递，实现了行为...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 630
1.导入hutool的maven依赖。2.复制一下代码执行。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
最新发布
m0_74283290的博客
08-03 666
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 556
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 494
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
c++ vector和stack
09-16
c++中的vector是一个能够存放任意类型的动态数组。...在使用vector时，可以使用insert和erase来插入和删除元素，可以使用size获取向量的大小，使用clear清空向量。此外，vector还具有反转和排序等功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值