Vector源码解析

于 2022-01-07 16:30:00 发布
阅读量626 收藏 1
点赞数 2
分类专栏： Java集合框架源码解析 文章标签： 容器 java 集合 arraylist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_46312987/article/details/122302158
版权

更多内容参考

1.Vector前导

1.1继承体系

在这里插入图片描述

1.2简单概述

Vector是一个古老的线程安全(内部的核心方法都加了synchronized)的容器，在JDK1.0时就已经存在，到如今已经很少使用。基本结构与ArrayList类似，可以认为是线程安全版本的ArrayList，但因为Vector效率低下，所以在多线程下使用的基本都是 CopyOnWriteArrayList() 其效率更高。

2.核心结构

2.1属性

    //底层存储数据的数组
	protected Object[] elementData;
	
    //数组中的元素个数
    protected int elementCount;
	
    /*
     * 扩容时指定扩容的容量(>0)，即扩容后的容量为 oldCap + capacityIncrement
     * 若没有指定，那么默认扩容为原容量的2倍，即扩容后的容量为 2 * oldCap
     */
    protected int capacityIncrement;

2.2构造器

调用无参构造器时，默认初始化容量为10

// ------------------------------ 构造器1 ------------------------------------
	
	/*
     *   传入初始容量和扩容数量
     *    这里跟ArrayList不同的是，Vector是非懒加载的，调用构造器就会
     *    初始化数组
     */
	public Vector(int initialCapacity, int capacityIncrement) {	
        //判断初始容量是否合法
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        //直接构造数组赋值给内部的elementData。
        this.elementData = new Object[initialCapacity];
        //传入的扩容数量赋值给capacityIncrement
        this.capacityIncrement = capacityIncrement;
    }
	
// ------------------------------ 构造器2 -------------------------------------

	/*
	 * 调用是构造器1，只是扩容数量传入的是0，即扩容时默认扩容为原长度的2倍。
	 *
	 */
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }

// ------------------------------ 构造器3 -------------------------------------

	/*
	 *  底层调用构造器2. 默认初始化长度为10. capacityIncrement为0.
	 */
    public Vector() {
        this(10);
    }

3.核心方法

3.1add()

  	/*
  	 *  加锁方法，线程安全。 
  	 */
	public synchronized boolean add(E e) {
        modCount++;
        add(e, elementData, elementCount);
        return true;
    }

//              ||    
//  		    ||
// 				\/
	
	/*
	 *  @param e 添加的元素
	 *  @param elementData 内部数组 
	 *  @param s 元素个数
	 */
    private void add(E e, Object[] elementData, int s) {
        //判断元素个数等于数组长度，下面是扩容的逻辑
        if (s == elementData.length)
            elementData = grow();
        //s就是待插入的位置，将e放到集合中
        elementData[s] = e;
        //元素个数+1
        elementCount = s + 1;
    }

3.2*grow()/newCapacity()

    /*
     *  调用了重载的带参数的grow(int minCapacity)方法
     */
	private Object[] grow() {
        return grow(elementCount + 1);
    }
	
	
//              ||    
//  		    ||
// 				\/

	/*
	 *  1.首先调用newCapacity()方法，计算出扩容后数组的容量x
	 *  2.然后调用Arrays.copyOf()方法重新创建一个长度为x的数组，然后将
	 *    原数组中的数据拷贝过去。完成扩容操作
	 * 
	 *   @param minCapacity 当前数组需要存放的元素的个数(即所需要的长度)
	 */
	private Object[] grow(int minCapacity) {
        return elementData = Arrays.copyOf(elementData,
                                           newCapacity(minCapacity));
    }

newCapacity()

扩容大致流程

这里只关注普通情况，因为一般一个集合中的元素个数不会达到INF级别。

  • 当 capacityIncrement大于0 时，newCap = oldCap + capacityIncrement
  • 否则 newCap = oldCap * 2
    /*
     * 计算出最终扩容后的数组长度。
     */
	private int newCapacity(int minCapacity) {
        //获取当前数组长度
        int oldCapacity = elementData.length;
        
        /*
         * 这里就是计算扩容后的长度的核心。
         *   1.首先判断capacityIncrement是否大于0，如果大于0，那么这次扩容的长度为
         *   oldCapacity + capacityIncrement
         *   2.否则，扩容后的长度为 oldCapacity * 2
         */
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        
        //判断按照上面的计算后是否满足当前所需要的长度，不满足的话进入if语句
        if (newCapacity - minCapacity <= 0) {
            //溢出 直接抛错
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            //没有溢出，直接将当前所需要的长度返回
            return minCapacity;
        }
        
        /*
         * MAX_ARRAY_SIZE = INF - 8
         * 这里去判断newCapacity是否溢出或者newCapacity大于MAX_ARRAY_SIZE
         * 并且没有溢出，此时直接分配INF。
         *   这里的处理ArrayList相同，参考
         * [https://blog.youkuaiyun.com/qq_46312987/article/details/122096262]
         */
        return (newCapacity - MAX_ARRAY_SIZE <= 0)
            ? newCapacity
            : hugeCapacity(minCapacity);
    }

//              ||    
//  		    ||
// 				\/

    private static int hugeCapacity(int minCapacity) {
        //溢出 直接抛OOM
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        
        return (minCapacity > MAX_ARRAY_SIZE) ?
            //minCapacity > MAX_ARRAY_SIZE 并且没有溢出(上面if判断)，直接分配INF
            Integer.MAX_VALUE :
        	//否则分配MAX_ARRAY_SIZE
            MAX_ARRAY_SIZE;
    }

3.3remove()

    /*
     *  (同步方法) 将指定索引位置的元素置为NULL
     */
	public synchronized E remove(int index) {
        modCount++;
        //越界判断
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        //获取index位置的元素
        E oldValue = elementData(index);
		
        //这里计算出当前准备删除的元素后有多少个元素
        int numMoved = elementCount - index - 1;
        
        //调用System.arraycopy变向的将index位置后面的所有元素往前移动一位
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        //将最后一个位置置为NULL。
        elementData[--elementCount] = null; // Let gc do its work
		
        //返回旧的value。
        return oldValue;
    }


//              ||    
//  		    ||
// 				\/
	
	/*
	 * 获取指定索引位置的元素
	 */
    E elementData(int index) {
        return (E) elementData[index];
    }

3.4set()

    /*
     * (同步方法) 修改指定索引位置的元素
     */
	public synchronized E set(int index, E element) {
        //判断索引是否越界
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
		//获取index位置的元素
        E oldValue = elementData(index);
        //替换
        elementData[index] = element;
        //返回原元素
        return oldValue;
    }

3.5size()/isEmpty()

    //返回elementCount
	public synchronized int size() {
        return elementCount;
    }
	
	//判断elementCount是否为0
    public synchronized boolean isEmpty() {
        return elementCount == 0;
    }

3.6get()

   /*
    * 同步方法 获取指定索引位置的元素
    */
	public synchronized E get(int index) {
		// 索引越界判断
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
		//直接返回index位置的元素。
        return elementData(index);
    }

//              ||    
//  		    ||
// 				\/
	
	/*
	 * 获取指定索引位置的元素
	 */
    E elementData(int index) {
        return (E) elementData[index];
    }

4.总结

  • Vector是非懒加载的，调用无参构造器时默认会初始化一个长度为10的数组。

  • 默认的扩容为原长度的2倍(ArrayList为1.5倍)(未给capacityIncrement赋值时)。

  • Vector的方法基本都是加了synchronized的，是一个线程安全的容器。

由于Vector现在基本不用，所以这里只讲解了其核心的方法，下期我们简单分析一下Vector的子类-Stack的源码。

【C++】Vector的使用和源码解析
meeiuliuus的博客
03-17 1464
其实很早之前，我就有去看STL源码的想法了。只是一直没有一个好的机会。最久空闲时间比较多，也正是这样一个好机会去阅读源码。为了事半功倍，不走弯路，我在网上查了很多资料。目前来说，C++ STL的源码相关的中文书籍还停留在侯捷老师的2002年出版的STL源码剖析。虽然侯捷老师确实是非常厉害的，很有教学能力的一位C++老师，但是还是要提，在计算机技术日新月异的环境下，一本二十多年前的书籍确实已经有点落后了。
Vector 源码解析
u011035026的博客
11-07 1543
使用Java中的数组二次封装属于我们的数组 实现增加元素、删除元素、修改元素、搜索元素功能。 使用泛型。 支持动态扩容。 /** * 通过对数组封装实现自己的Array类 */ public class Array&amp;amp;amp;amp;amp;amp;amp;lt;E&amp;amp;amp;amp;amp;amp;amp;gt; { //定义一个整型的一维数组的成员变量 private E[] data; //数组中元素的个数，手动去维系它
《STL源码剖析》-- stl_vector.h
一个人的战争
07-28 7120
// Filename: stl_vector.h // Comment By: 凝霜 // E-mail: mdl2009@vip.qq.com // Blog: http://blog.youkuaiyun.com/mdl13412 /* * *
JAVA Vector源码解析和示例代码
09-04
【JAVA Vector 源码解析和示例代码】 在Java编程语言中，`Vector`类是集合框架的一部分，早在JDK 1.0版本就已经存在。`Vector`类继承自`AbstractList`并实现了`List`, `RandomAccess`, `Cloneable`等接口，提供了...
C语言实现矩阵操作的vector源码解析
具体到这个项目，“matcom1,c语言vector源码,c语言程序”可能指的就是一个实现了类似vector功能的库，这个库允许用户方便快捷地处理矩阵数据。这样的库可能会提供如下的接口函数： - 初始化vector - 添加元素 - ...
深入浅出java.util.vector源码解析
Vector源码中最重要的部分是它的扩容机制。当向Vector添加新元素而当前容量不足时，会进行扩容操作，通常新容量是当前容量的两倍，这个策略可以通过构造函数中的capacityIncrement参数修改。 ```java protected ...
vector源码.cpp
11-30
vector源码.cpp，运用c++实现容器vector的编写
Vector类源码详解
LYQ20010417的博客
11-11 981
一、源码分析 1.继承的父类&实现的接口 public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable 继承了AbstractList类（继承后可以使用迭代器遍历）， 实现了RandomAccess(标记接口，标明实现该接口的list支持快速随机访问)， cloneable接口（标识接
Vector源码
csdn86868686888的博客
05-03 235
不加注释了，跟ArrayList差不多，唯一的不同是对元素操作、扩容等等都进行了同步了，实质就是加了同步的操作 package java.util; import java.util.function.Consumer; import java.util.function.Predicate; import java.util.function.UnaryOperator; public...
Vector源码剖析
IT忍者神龟
07-02 724
Vector简介     Vector也是基于数组实现的，是一个动态数组，其容量能自动增长。     LinkedList是JDK1.0引入了，它的很多实现方法都加入了同步语句，因此是线程安全的（其实也只是相对安全，有些时候还是要加入同步语句来保证线程的安全），可以用于多线程环境。     LinkedList没有丝线Serializable接口，因此它不支持序列化，实现
vector源码分析
愤怒的弱鸡
08-14 1271
这里引用源码中的一段描述 In some terminology a %vector can be described as a dynamic C-style array, it offers fast and efficient access to individual elements in any order and saves the user from worrying aboutmemory and size allocation. vector毫不夸张得说就是有动态内存分配功能的传统数组
【Java集合源码剖析】Vector源码剖析
热门推荐
兰亭风雨的专栏
07-02 1万+
Vector简介 Vector也是基于数组实现的，是一个动态数组，其容量能自动增长。 LinkedList是JDK1.0引入了，它的很多实现方法都加入了同步语句，因此是线程安全的（其实也只是相对安全，有些时候还是要加入同步语句来保证线程的安全），可以用于多线程环境。 LinkedList没有丝线Serializable接口，因此它不支持序列化，实现了Cloneable接口，能被克隆，实现了RandomAccess接口，支持快速随机访问。 Vector源码剖析 Vector的
Vector类源码解析
水滴石穿
07-15 1836
Vector特点： 1.内部通过数组实现 2.通过synchronized同步方法，线程安全，适合多线程 3.由于线程安全，效率不高 4.默认存放10个元素 所在包package java.util;继承AbstractList 实现List 、RandomAccess、Cloneable、java.io.Serializable Clone： 简单的说就是clone一个对象实例。使
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

shstart7

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

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

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

打赏作者

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

抵扣说明：

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

余额充值