Vector源码分析(jdk1.8)

最新推荐文章于 2021-10-28 12:31:08 发布
最新推荐文章于 2021-10-28 12:31:08 发布
阅读量336 收藏
点赞数
分类专栏： Java基础 文章标签： Vector源码分析(jdk1.8)
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhwyj1019/article/details/81291049
版权

简介：

通过阅读源码发现Vector和ArrayList基本上是很相似的，只是Vector的增删改查方法上都加了synchronized关键字，所以是线程安全的，但是直接通过synchronized同步机制实现的线程安全会导致效率很低，所以基本上Vector很少被使用，下面就是Vector的增删改查方法和一起辅助方法的源码分析。本来是不打算看这个源码的，想想还是看一下吧，雨露均沾是不是：）

成员变量

    /**
     * Vector底层数组
     */
    protected Object[] elementData;

    /**
     * 底层数组的元素个数
     */
    protected int elementCount;

    /**
     * 扩容大小，即每次扩容增长的容量，默认扩容为原来容量的两倍。
     */
    protected int capacityIncrement;

    /** 序列号 */
    private static final long serialVersionUID = -2767605614048989439L;

构造器

构造器的代码很简单，就没有写太多注释了。这里并没有使用lazy-load机制，和其他大部分集合框架1.8更新的还是有点区别的，可能是使用的场景太少了，已经没有进行过维护了：）

    /**
     * 自定义初始化容量，和扩容大小的构造器
     */
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

    /**
     * 自定义初始化容量的构造器
     */
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }

    /**
     * 默认构造器，默认初始化容量为 10，扩容标志为 0
     */
    public Vector() {
        this(10);
    }

    /**
     * 自定义集合的构造器
     */
    public Vector(Collection<? extends E> c) {
        // 集合转成数组
        elementData = c.toArray();
        // 元素数就是指定集合中的元素素
        elementCount = elementData.length;
        // 不是Object[],则转成Object[]
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }

add方法

add方法无非是指定元素并指定索引，或者指定元素不指定索引。

    /**
     * 添加元素，从末尾添加（线程安全的）
     */
    public synchronized boolean add(E e) {
        // 操作记录数加1
        modCount++;
        // 确认是否进行扩容
        ensureCapacityHelper(elementCount + 1);
        // 在末尾添加新的元素
        elementData[elementCount++] = e;
        return true;
    }
    /**
     * 指定位置插入指定元素
     */
    public void add(int index, E element) {
        insertElementAt(element, index);
    }

    /**
     * 指定位置插入指定元素的具体方法
     */
    public synchronized void insertElementAt(E obj, int index) {
        // 操作记录数加1
        modCount++;
        if (index > elementCount) {
            throw new ArrayIndexOutOfBoundsException(index
                                                     + " > " + elementCount);
        }
        // 确认是否进行扩容
        ensureCapacityHelper(elementCount + 1);
        // 插入位置之后的元素进行索引重排
        System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
        // 将新元素赋值给插入位置
        elementData[index] = obj;
        // 元素个数加1
        elementCount++;
    }

    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

指定位置插入指定元素方法的帮助理解图：
这里写图片描述
增加方法必然会设计到扩容的方法，下面是源码

    /**
     * 确认扩容
     */
    public synchronized void ensureCapacity(int minCapacity) {
        if (minCapacity > 0) {
            modCount++;
            ensureCapacityHelper(minCapacity);
        }
    }

    /**
     * 确认扩容的方法，这个方法不是一个线程安全的方法，所以其他线程安全的方法在调用这个方法时
     * ，不会产生额外的开销（加锁，释放锁）。
     */
    private void ensureCapacityHelper(int minCapacity) {
        // 最小的元素个数比底层数组容量大时进行扩容
        if (minCapacity - elementData.length > 0)
            // 调用具体的扩容方法
            grow(minCapacity);
    }

具体的grow方法

    /**
     * 我感觉这个是即将越界前的此次扩容缓冲值，防止扩容时发生越界
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    private void grow(int minCapacity) {
        // 记录扩容前数组的容量(长度)
        int oldCapacity = elementData.length;
        // 计算扩容后的数组容量，再没有有指定扩容大小的时候，默认扩容为原谅容量的两倍
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            // 这个操作我想可能是为了防止自定义的 capacityIncrement 为负数吧。
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            // 调用判断容量是否符合int类型的范围的方法
            newCapacity = hugeCapacity(minCapacity);
        // 创建扩容后的数组，并将原来数组中的元素copy到新的数组中，再设置为Vector的底层数组
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    /**
     * 判断容量是否符合int类型的范围的方法
     */
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

还有两个插入指定集合中所有元素的方法，也是分为指定索引和不指定。

    /**
     * 在末尾添加指定集合中的所有元素
     */
    public synchronized boolean addAll(Collection<? extends E> c) {
        // 操作记录数加1
        modCount++;
        // 集合转成数组
        Object[] a = c.toArray();
        // 记录指定集合中元素个数
        int numNew = a.length;
        // 扩容检查
        ensureCapacityHelper(elementCount + numNew);
        // 末尾插入元素
        System.arraycopy(a, 0, elementData, elementCount, numNew);
        // 设置元素个数
        elementCount += numNew;
        return numNew != 0;
    }

    /**
     * 在指定位置添加指定集合中的所有元素到当前Vector中
     */
    public synchronized boolean addAll(int index, Collection<? extends E> c) {
        // 操作记录数加1
        modCount++;
        if (index < 0 || index > elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        // 集合转成数组
        Object[] a = c.toArray();
        // 记录指定集合中的元素个数
        int numNew = a.length;
        // 扩容检查
        ensureCapacityHelper(elementCount + numNew);
        // 计算插入位置
        int numMoved = elementCount - index;
        if (numMoved > 0)
            // 索引重排
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);
        // 插入新元素
        System.arraycopy(a, 0, elementData, index, numNew);
        // 设置元素个数
        elementCount += numNew;
        return numNew != 0;
    }

remove方法

删除方法分为：删除指定元素和删除指定索引位置的元素。

    /**
     * 删除指定索引位置的元素，并返回删除的元素
     */
    public synchronized E remove(int index) {
        // 操作记录数加1
        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);
        // 将最后一个元素赋值为null
        elementData[--elementCount] = null; // Let gc do its work
        // 返回删除的元素
        return oldValue;
    }


    /**
     * 删除指定元素，本质还是根据索引删除，先去找到指定元素对应的索引，再根据索引删除
     */
    public boolean remove(Object o) {
        // 调用删除元素方法
        return removeElement(o);
    }

    /**
     * 删除指定元素
     */
    public synchronized boolean removeElement(Object obj) {
        // 操作记录数加1
        modCount++;
        // 寻找指定元素的索引
        int i = indexOf(obj);
        if (i >= 0) {
            // 本质上还是通过索引来删除
            removeElementAt(i);
            return true;
        }
        return false;
    }

    /**
     * 寻找指定元素的索引
     */
    public int indexOf(Object o) {
        return indexOf(o, 0);
    }

    /**
     * 寻找指定元素的索引，这个方法也是用来查询指定索引之后是否包含指定元素的方法。
     */
    public synchronized int indexOf(Object o, int index) {
        // 遍历寻找指定元素，判断null，应为null不能调用equals方法
        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;
        }
        // 没有这个元素，返回-1
        return -1;
    }

    /**
     * 删除指定索引的元素，基本上和remove(int) 方法一样，只是没有返回值，这里就没写注释了
     */
    public synchronized void removeElementAt(int index) {
        modCount++;
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        else if (index < 0) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        int j = elementCount - index - 1;
        if (j > 0) {
            System.arraycopy(elementData, index + 1, elementData, index, j);
        }
        elementCount--;
        elementData[elementCount] = null; /* to let gc do its work */
    }

删除指定索引的元素方法的帮助理解图：
这里写图片描述
下面还有一些批量删除的方法

    /**
     * 删除在 fromIndex 到 toIndex 之间的元素
     */
    protected synchronized void removeRange(int fromIndex, int toIndex) {
        // 操作记录数加1
        modCount++;
        // 记录删除元素的个数
        int numMoved = elementCount - toIndex;
        // 进行数组重排
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);

        // 计算删除后的元素个数
        int newElementCount = elementCount - (toIndex-fromIndex);
        // 遍历将 toIndex 之后的元素赋值为null
        while (elementCount != newElementCount)
            elementData[--elementCount] = null;
    }

    /**
     * 删除所有元素
     */
    public void clear() {
        removeAllElements();
    }   

    /**
     * 删除所有元素，简单的将所有元素赋值为null，并将元素数设置为0
     */
    public synchronized void removeAllElements() {
        // 操作记录数加1
        modCount++;
        // 遍历将所有元素赋值为null
        for (int i = 0; i < elementCount; i++)
            elementData[i] = null;
        // 元素数赋值为0
        elementCount = 0;
    }

get方法

get方法就更简单了

    /**
     * 获取指定索引的元素值
     */
    public synchronized E get(int index) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        return elementData(index);
    }

    /**
     * 获取第一个元素
     */
    public synchronized E firstElement() {
        if (elementCount == 0) {
            throw new NoSuchElementException();
        }
        return elementData(0);
    }

    /**
     * 获取最后一个元素
     */
    public synchronized E lastElement() {
        if (elementCount == 0) {
            throw new NoSuchElementException();
        }
        return elementData(elementCount - 1);
    }

set方法

    /**
     * 修改指定索引位置的值为指定值，并返回修改之前的值
     */
    public synchronized E set(int index, E element) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        // 记录修改之前的元素值
        E oldValue = elementData(index);
        // 将指定值赋值给指定索引位置
        elementData[index] = element;
        // 返回修改之前的值
        return oldValue;
    }

    /**
     * 删除指定索引位置的元素，没有返回值，逻辑和set(E,int)方法一样
     */
    public synchronized void setElementAt(E obj, int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        elementData[index] = obj;
    }

其他方法

    /**
     * 线程安全的copy方法,将Vector底层数组中的所有元素copy到指定数组上
     */
    public synchronized void copyInto(Object[] anArray) {
        System.arraycopy(elementData, 0, anArray, 0, elementCount);
    }

    /**
     * 获取容量
     */
    public synchronized int capacity() {
        return elementData.length;
    }

    /**
     * 获取元素个数
     */
    public synchronized int size() {
        return elementCount;
    }

    /**
     * 判断Vector是否为空
     */
    public synchronized boolean isEmpty() {
        return elementCount == 0;
    }

    /**
     * 判断是否存在指定元素
     */
    public boolean contains(Object o) {
        return indexOf(o, 0) >= 0;
    }

    /**
     * 是否全部包含指定集合中的元素
     */
    public synchronized boolean containsAll(Collection<?> c) {
        return super.containsAll(c);
    }

这样Vector的源就看完了。

innerpeacez
关注
专栏目录
【Java集合源码剖析】Vector源码剖析
兰亭风雨的专栏
07-02 1万+
Vector简介 Vector也是基于数组实现的，是一个动态数组，其容量能自动增长。 LinkedList是JDK1.0引入了，它的很多实现方法都加入了同步语句，因此是线程安全的（其实也只是相对安全，有些时候还是要加入同步语句来保证线程的安全），可以用于多线程环境。 LinkedList没有丝线Serializable接口，因此它不支持序列化，实现了Cloneable接口，能被克隆，实现了RandomAccess接口，支持快速随机访问。 Vector源码剖析 Vector的
ConcurrentHashMap源码jdk1.7及1.8的区别
m0_51332138的博客
06-24 249
ConcurrenHashmap线程安全的集合ConcurrentHashMap分析 jdk1.7ConcurrentHashMap分析 jdk1.8线程安全的集合为什么要使用ConcurrentHashMapConcurrentHashMap分析 jdk1.7属性构造函数put()get()size分段锁是什么？？高并发性ConcurrentHashMap分析 jdk1.8put方法get（）size区别 线程安全的集合 ConcurrentHashMap分析 jdk1.7 ConcurrentHashM
Vector简介
it_yangkun的博客
10-05 239
Vector简介 Vector也是基于数组实现的，是一个动态数组，其容量能自动增长。 Vector是JDK1.0引入了，它的很多实现方法都加入了同步语句，因此是线程安全的（其实也只是相对安全，有些时候还是要加入同步语句来保证线程的安全），可以用于多线程环境。 Vector没有实现Serializable接口，因此它不支持序列化，实现了Cloneable接口，能被克隆，实现了Ran
JDK1.8源码阅读系列之三：Vector
weixin_34360651的博客
01-26 78
　　 　　本篇随笔主要描述的是我阅读 Vector 源码期间的对于 Vector 的一些实现上的个人理解，用于个人备忘，有不对的地方，请指出～ 　　先来看一下 Vector的继承图：　　　　可以看出，Vector 的直接父类是 AbstractList（已在JDK1.8源码阅读系列之一介绍过）， 直接子类是 Stack（下一篇文章介绍）。 　　在 Vector 类源码中，我认为有以下几个地...
jdk1.8-Vector
weixin_33918114的博客
03-16 143
一：先看下类的继承关系UML图如下：继承关系：public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.SerializableRandmoAccess快速随机访问接口二：看下成员属性/** * The arr...
Vector源码剖析
IT忍者神龟
07-02 698
Vector简介     Vector也是基于数组实现的，是一个动态数组，其容量能自动增长。     LinkedList是JDK1.0引入了，它的很多实现方法都加入了同步语句，因此是线程安全的（其实也只是相对安全，有些时候还是要加入同步语句来保证线程的安全），可以用于多线程环境。     LinkedList没有丝线Serializable接口，因此它不支持序列化，实现
【JDK1.8源码剖析】Collection接口
01-20
文章目录Collection源码剖析（一）简介（二）源码分析 Collection源码剖析 （一）简介 Collection接口是集合层次结构中的根接口。 （1）下面是常用集合类关系图 Collection 　|___List　有序，可重复 　|___...
java8源码-JDKSourceCode:阅读jdk1.8的一些注意事项
06-04
初始化仓库，其实这份源码之前有阅读过一点,有一些注释现在正是开始同步写博客分析 Java8 源码 博客地址: ArrayList ctor-3 get set add-2 remove-2 clear addAll write/readObject fast-fail subList iterator ...
源码—ArrayList(JDK 1.8)
qq_40639963的博客
03-02 81
文章目录源码——ArrayList（JDK 1.8）1. 属性2. 构造方法3. 重点方法3.1 get()3.2 set()3.3 add()1）无参构造扩容过程模拟2）参数为0的构造扩容过程3.4 remove()3.5 indexOf()和lastIndexOf()3.6 clear()4. 面试题4.1 ArrayList和LinkedList的区别？4.2 RandomAccess接口？4.3 ArrayList与Vector区别，为什么用ArrayList取代Vector？4.4 ArrayL
java8源码-csn-list:ArrayList、LinkedList、Vector、Stack源码分析
06-04
List相关实现类的源码解析（JDK1.8） 2018.9.22- List的架构图 ArrayList 继承关系： ArrayList -> AbstractList 实现 List接口 ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态...
Vector源码解析(jdk1.8)
yuminfeng728的博客
09-19 707
概述Vector实现了List的接口，底层同样是基于数组实现的，可以存储null。功能结构与ArrayList的类似，不同的是线程安全的。
Vector源码分析（JDK1.8）
starchao
03-23 305
转载地址：https://www.cnblogs.com/gxl1995/p/997333a2e6bb9985af5333b4286265d9.html 1.vector介绍 Vector是矢量队列，它继承了AbstractList，实现了List、 RandomAccess, Cloneable, java.io.Serializable接口。 Vector继承了AbstractList...
Vector源码解析
weixin_45467097的博客
09-13 371
概述 Vector是矢量队列。它是jdk1.0版本添加的类 继承 AbstractList、实现 List, RandomAccess, Cloneable, java.io.Serializable 这些接口. Vector底层数据结构是数组Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。 vector是线程（Thread）同步（
Vector源码解析(JDK1.8)
xuyilin3310的博客
07-24 181
文档头 Vector是可变长度数组 通过capacity 和 capacityIncrement 管理数据的存储空间 也是fast-fail的 是同步的 变量定义 protected Object[] elementData; // 元素数组 protected int elementCount; // 元素数量 protected int capaci...
Vector：源码分析
ysal4的博客
07-17 163
文章目录1、什么是Vector?2、Vector的源码分析3、Vector的扩容4、Vector和ArrayList的区别 1、什么是Vector?           Vector和ArrayList一样是一个集合，都实现了List接口 2、Vector的源码分析 我们首先看一下Vector中的几个属性: // 从这里我们可以看出Vector其实也是一个数组 protected Object[] e
Vector源码分析
ABidMan的博客
10-28 96
Vector源码分析 一、未初始化的vector数组 1、准备工作 package com.liu.List; import java.util.Vector; public class Vector_ { public static void main(String[] args) { Vector<Object> vector = new Vector<>(); for(int i=0; i<10; i++){
深入解析JDK1.8 ArrayList源码
"这篇分析基于JDK1.8的ArrayList源码，主要探讨ArrayList的核心特性，包括构造函数、成员变量、元素操作等。ArrayList作为Java中的动态数组，其内部使用一个Object类型的数组来存储元素，提供了高效查找但相对低效的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值