Collection探究之Vector

最新推荐文章于 2022-01-05 21:33:29 发布
最新推荐文章于 2022-01-05 21:33:29 发布
阅读量402 收藏
点赞数
分类专栏： java集合 文章标签： 线程安全 数组 性能 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/witness_mei/article/details/49530545
版权

Vector与ArrayList一样内部是由数组组成的，它也是一个动态数组，但是由于其内部实现了线程安全机制，所以在性能方面较差，使用的次数也没有ArrayList那样频繁，下面我们来看一看Vector的源码。

1.Vector的定义

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

与ArrayList一样，Vector继承了AbstractList，实现了List，RandomAccess，Cloneable与Serializable接口，所以它有着与ArrayList一样的功能。

2.Vector的属性

//Vector中用于保存数据的数组
protected Object[] elementData;
//Vector中数据的总量，也就是实际存储的数据的数量
protected int elementCount;
//Vector数组每次扩容时容器的增长量
protected int capacityIncrement;

3.Vector的构造函数

Vector 有四个构造函数，分别如下：

    //该构造函数指定了Vector容器的初始大小和每次扩容时容器增长量
    public Vector(int initialCapacity, int   capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        //可以看到该构造函数在初始化时新建了一个大小为 initialCapacity的数组，并为capacityIncrement赋值
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

   //只指定容器初始化大小
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }

  //默认初始化函数，用于构造容器大小为10的Vector
    public Vector() {
        this(10);
    }

    //参数为集合，用于生成一个新的Vector集合
    public Vector(Collection<? extends E> c) {
    //将集合c中的元素转换成为Vector中的数组元素
        elementData = c.toArray();
        //设置实际元素数量值
        elementCount = elementData.length;
        若elementData不为Object类型的数组，则将其转换成为Object类型的数组
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }

4.Vector常用操作方法

4.1获取元素

//可以看到Vector中的方法都添加了synchronized关键字，因此它是线程同步的。
public synchronized E get(int index) {
        //查看输入的下标是否越界
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        //这里获取元素的功能由elementData方法完成
        return elementData(index);
    }

//由于Vector本质就是数组，因此可以使用下标获取元素，返回elementData中下标为index的元素
E elementData(int index) {
        return (E) elementData[index];
    }

4.2添加元素


public synchronized boolean add(E e) {
        modCount++;
        //添加元素时，先对数组进行扩容
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

//这是一个私有的内部方法
 private void ensureCapacityHelper(int minCapacity) {
        //检查是否越界，若没有则让grow进行扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

//设置Vector数组的最大长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    private void grow(int minCapacity) {
       //获取没扩容前数组的长度
        int oldCapacity = elementData.length;
        //扩容后的Vector数组大小，若capacityIncrement大于0，则在原数组长度上增加capacityIncrement长度，若capacityIncrement小于0，则在原数组的长度基础上扩容一倍
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
        //对扩容结果进行校验，minCapacity表示当前新数组所需的最小Vector数组长度
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //若newCapacity超过了数组的最大容量，则由hugeCapacity构建
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        //返回所能创建的数组的最大容量
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

//set方法为对Index下标的元素进行覆盖
  public synchronized void setElementAt(E obj, int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        elementData[index] = obj;
    }

//直接将元素添加到Vector数组的末尾
public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = obj;
    }

  //向Vector容器中批量添加元素
   public synchronized boolean addAll(Collection<? extends E> c) {
        modCount++;
        //先将c容器中的元素转换成为object类型的数组
        Object[] a = c.toArray();
        int numNew = a.length;
        //对Vector数组进行扩容
        ensureCapacityHelper(elementCount + numNew);
        //将c容器中的元素复制到Vector中
        System.arraycopy(a, 0, elementData, elementCount, numNew);
        //修改实际元素数量
        elementCount += numNew;
        return numNew != 0;
    }

//与上面的addAll方法差不多，只不过该方法是在Vector指定位置Index处添加集合C的元素
public synchronized boolean addAll(int index, Collection<? extends E> c) {
        modCount++;
        //检查是否越界
        if (index < 0 || index > elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityHelper(elementCount + numNew);
        //numMoved为需要移动元素的个数
        int numMoved = elementCount - index;
        if (numMoved > 0)
            //将原先Index处的numMoved个元素，向后移动到距离原位置numNew处
            System.arraycopy(elementData, index, elementData, index + numNew,numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        elementCount += numNew;
        return numNew != 0;

4.3删除元素

//用于移除Vector中的obj元素
public synchronized boolean removeElement(Object obj) {
        modCount++;
        //先用indexOf找到第一个值为obj元素的下标位置
        int i = indexOf(obj);
        if (i >= 0) {
            //移除该下标
            removeElementAt(i);
            return true;
        }
        return false;
    }

 public int indexOf(Object o) {
        return indexOf(o, 0);
    }
//该方法用于移除元素值为o的元素
public synchronized int indexOf(Object o, int index) {
        //Vector是允许元素值为null的
        if (o == null) {
            //从index开始向后进行遍历，找到第一个元素值为null的下标
            for (int i = index ; i < elementCount ; i++)
                if (elementData[i]==null)
                    return i;
        } else {
        //从index开始向后进行遍历，找到第一个元素值为o的下标
            for (int i = index ; i < elementCount ; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

//该方法用于移除Vector中的所有元素
 public synchronized void removeAllElements() {
        modCount++;
        // Let gc do its work
        for (int i = 0; i < elementCount; i++)
            elementData[i] = null;

        elementCount = 0;
    }

//移除指定位置index处的元素
public synchronized E remove(int index) {
        modCount++;
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        //获取原先index处的值
        E oldValue = elementData(index);
        //需要移动的距离
        int numMoved = elementCount - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,numMoved);
        elementData[--elementCount] = null; 
        return oldValue;
    }

5一般常用方法

//该方法用于对Vector数组进行扩容
public synchronized void setSize(int newSize) {
        modCount++;
        //若新容器大小大于实际元素值，则扩容
        if (newSize > elementCount) {
            ensureCapacityHelper(newSize);
        } else {
        //若小于，则将Vector后elementCount－newSize个元素删除
            for (int i = newSize ; i < elementCount ; i++) {

                elementData[i] = null;
            }
        }
        elementCount = newSize;
    }

//返回Vector容器中实际元素个数
   public synchronized int size() {
        return elementCount;
    }

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

//返回所有的元素
 public Enumeration<E> elements() {
         //匿名函数
        return new Enumeration<E>() {
            int count = 0;
            //是否还有元素
            public boolean hasMoreElements() {
                return count < elementCount;
            }

            //返回元素
            public E nextElement() {
                synchronized (Vector.this) {
                    if (count < elementCount) {
                        return elementData(count++);
                    }
                }
                throw new NoSuchElementException("Vector Enumeration");
            }
        };
    }

//检查Vector中是否包含o对象
public boolean contains(Object o) {
        return indexOf(o, 0) >= 0;
    }

Vector就分析那么多， 一般情况下Vector使用的频率不是很高，所以要记住它与ArrayList的区别即可。

Alvin-M
关注
专栏目录
Java List 扩容机制探究（ArrayList 、Vector、LinkedList）
流楚丶格念的博客
10-16 3069
ensureExplicitCapacity方法会调用grow方法，扩容1.5倍，就是在此发生的。ensureCapacityInternal方法会调用ensureExplicitCapacity方法来确保空间，modCount用来多线程的判断，此处不赘述。调试下我们可以发现，虽然elementData进行了扩容，但是实际大小还是元素的个数，别被唬住了。方法，capacityIncrement默认是0，所以等价。初始化会默认调用无参，再调用有参数构造器，空间默认10。这是第二次扩容为，扩容为15。
⭐⭐⭐⭐⭐Linux C++性能优化秘籍：从编译器到代码，探究高性能C++程序的实现之道
最新发布
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
04-06 1928
高性能C++编程涉及多个方面，包括编译器优化、C++代码性能优化基本原则、C++对象管理与性能优化、多线程编程与性能优化、Linux系统调用优化等。通过学习和掌握这些要点，程序员可以有效地提高C++程序在Linux环境下的性能。接下来的章节将对这些核心要点进行详细的介绍。
collection和vector介绍
Anolzo
01-05 459
Java—集合之collection Collcetion是一个接口，主要的两个分支是List（有序的队列，可以有重复的元素）和Set（数学概念中的集合，没有重复元素） java集合框架主要由Collection和Map两个根接口及其子接口,实现类组成 Collcetion简介 Collection的定义 public interface Collection<E> extends Iterable<E> {} JDK不提供此接口的任何直接实现：它提供了更具体的子接口的实现，如 S
详解Collection中的Vector
Cxf2018的博客
10-28 410
一、Vector简介 java.util.vector提供了向量类（Vector）以实现类似动态数组的功能；创建一个向量类对象以后，可以随意插入不同类的对象，不用顾及类型也不用预先选定容量，并可以实现方便的查找。 适应场景：预先不知道或者不愿预先定义数组大小，并且需要频繁的查找，插入，删除的工作情况，可以考虑使用向量类。 向量类提供了三种构造方法： public vector() public vector(int initialcapacity,int capacityIncrement) pub
vector和iterator及collection
weixin_33739627的博客
01-07 195
Collection是所有集合的最上层接口，它里面定义了所有集合对象都可以进行的操作；它有两个子接口，分别是List和Set。List会记录放在其中元素的放入顺序，形象地说，可以认为是一个传送带，它上面所有的东西都有一个放置顺序。而Set要求放置在其中的元素必须不能重复，它与数学上集合的概念完全一致。Iterator又称迭带器，能对Collection进行顺序遍历。Vector是List接口的一个...
java Collection-Vector
qq_41786692的博客
03-17 551
一、Vector的概念1.vector实现了一个可以自动增长的对象数组，类似于动态数组，能够动态的调整自身的大小，能够根据索引进行查询；2.vector继承了AbstractList，实现了List，是一个队列，实现了相应的增删改查等功能；3.vector实现了RnadomAccess接口，因此能够对数据进行随机访问；4.vector的操作是线程安全的，Vector中的大部分方法增加了ychron...
Collection集合详细介绍-Vector
weixin_41007138的博客
04-06 185
概述： List接口和Set接口以及Queue接口属于Collection接口，Map接口和Collection接口并列存在（同级）。 List(元素可重复性，有序性): Set（具有唯一性，无序性）: Queue： 基本上，一个队列就是一个先入先出（FIFO）的数据结构 Map（采用键值对<key,value>存储元素，key键唯一） Queue接口下面有两个个实现类：LinkedList，PriorityQueue 详细说明 LinkedList https://editor.csdn.n.
你知道synchronizedList和Vector底层原理实现和区别吗？其实开始我也不知道！（超详细源码分析）
奈何的人生
03-15 994
疑问：同样都是加了锁的集合，为什么synchronizedList比Vector快呢？
FIR滤波器设计中的Python实现技巧探究
# 1. FIR滤波器简介 ## 1.1 FIR滤波器的基本概念和原理 在数字信号处理中，FIR（有限脉冲响应）滤波器是一种常见的滤波器类型。FIR滤波器的基本原理是利用有限长度的脉冲响应来对输入信号进行滤波处理，其输出仅取...
Linux中的定时器与中断处理技术探究
# 1. Linux中的定时器技术 ## 1.1 定时器的概念与作用 定时器是计算机系统中用于按预定时间来触发某些操作的一种机制。它可以用来定时执行任务、调度进程、处理事件等。在Linux系统中，定时器起着重要的作用，它...
Java 集合系列06之 Vector详细介绍(源码解析)和使用示例
挖坑埋你
08-16 322
概要 学完 ArrayList 和 LinkedList 之后，我们接着学习 Vector。学习方式还是和之前一样，先对Vector有个整体认识，然后再学习它的源码；最后再通过实例来学会使用它。 第1部分 Vector介绍 第2部分 Vector数据结构 第3部分 Vector源码解析(基于JDK1.6.0_45) 第4部分 Vector遍历方式 第5部分 Vector示例 第1...
Collection容器家族(Vector讲解及Stack源码详解）
IdealSpring的博客
09-12 364
Vector讲解         Vector类称作向量类，它实现了动态数组，用于元素数量变化的对象数组。像数组一样，vector类也用从0开始的下标表示元素的位置；但和数组不同的是，当vector对象创建后，数组的元素个数会随着vector对象元素个数的增大和缩小而自动变化。         Vector的数据结构和ArrayList差不多，它包含了3个成员变量：elementData , ...
vector继承Collection
yy1711408814的博客
03-08 1146
package com.newedu.jb.day17.collection; import java.util.Enumeration;import java.util.ListIterator;import java.util.Vector; /** *Vector 的特点： *  * 1：内部是数组，查询快，增删慢 * 2：存取有序，因为实现了List接口。 * 3：允许有重复元素。 * 4...
16-Java集合框架(collection、List和vector)
青木年华
08-11 192
###15.01_集合框架(对象数组的概述和使用) * A:案例演示     * 需求：我有5个学生，请把这个5个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。 *          Student[] arr = new Student[5];                    //存储学生对象         arr[0] = new Student("张三", 23);  ...
java collection_Java基础学习之Collection—List线程安全篇（Vector）
weixin_39838328的博客
11-28 104
前言老规矩，先把官方注释完整的放出来。/** 其实这里面的注释内容有关于快速失败和迭代器的部分跟LinkedList和ArrayList是一模一样的，我挑选一些Vector的特性把重点翻译一下。Vector类实现了一个可增长（growable）的数组对象，类似数组，它包含可以使用整数索引访问的组件。但是，在Vector创建之后，它的大小可以根据需要增长或缩小，以适应添加和删除等操作。每个Vect...
Collection与Collections的区别，ArrayList和Vector的区别-----一道面试题
我是谁的专栏
05-10 2413
Collection 和 Collections的区别。 Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。 ---是一个类 Collection是个java.util下的接口，它是各种集合结构的父接口。 -----是一个接口 Collection是集合类接口,是所有集合类的,父类,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其
实现或继承了Collection接口的是（）
热门推荐
PengTan
10-31 1万+
答案：BCEA，Map接口未实现Collection接口 B，List接口的定义为 public interface Listextends CollectionC，Vector定义为 public class Vectorextends AbstractListimplements List, RandomAccess, Cloneable, Serializable Vector实现了L
理解Java Vector类与Collection接口的同步特性
本资源主要介绍了Java中的Vector类，它是Collection集合的一个子类，但与ArrayList有所不同。Vector是线程安全的，这意味着在多线程环境下，它提供了同步机制，保证了在并发访问时数据的一致性。然而，这也会带来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值