Java集合学习（二）Vector源码学习

最新推荐文章于 2025-12-02 15:55:42 发布

原创最新推荐文章于 2025-12-02 15:55:42 发布 · 213 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #数据结构

Java集合专栏收录该内容

3 篇文章

订阅专栏

本文深入探讨了Java中的Vector类，解析其作为线程安全动态数组的实现原理，包括成员变量、构造函数、扩容、添加、查找及删除等核心方法，对比ArrayList，揭示Vector的线程安全性与效率之间的权衡。

Java集合学习（二）Vector源码学习

前言

侵删，学习记录笔记。

Vector

与ArrayList类似，都是动态数组，底层也都是使用数组实现。但与ArrayList最大的区别在于Vector是同步的，线程安全的，不过由于线程安全，所以效率低。

成员变量


	//底层数组，用于存放数据
    protected Object[] elementData;

 	//数组当前元素数量
    protected int elementCount;

  	//容量扩容数，用于数组扩容
    protected int capacityIncrement;

    private static final long serialVersionUID = -2767605614048989439L;

构造函数

  
//Vector(初始容量，容量扩容数)
// 初始容量必须大于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;
    }

	//Vector(初始容量)
	//根据初始容量初始化数组，并将扩容数设置为0
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }


	//Vector()
	//初始化一个容量为10长度的数组，并将扩容数设置为0
    public Vector() {
        this(10);
    }

 	//Vector(Collection<? extends E> c)
	//根据Collection来构造Vector
    public Vector(Collection<? extends E> c) {
        elementData = c.toArray();
        elementCount = elementData.length;
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }

扩容函数

 
//数组的最大允许容量
//由于某些虚拟机在数组中保留一些头字，尝试分配这个最大存储容量
//可能会导致数组容量大于虚拟机的limit，导致OutOfMemoryError。
 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

//扩容函数
private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
    	//如果扩容数小于0则新容量为旧容量的两倍，否则为旧容量+扩容数
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
    //当新容量仍然小于最小期望容量，则将新容量再次赋值为最小期望容量minCapacity
        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) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

添加函数

   //添加函数
	//先增加modCount（修改次数）
	//判断当前数组容量是否能容纳新元素，不够则进行扩容
	//添加元素，返回true
public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

    //比较最小期望容量与数组长度，长度不够则扩容
    private void ensureCapacityHelper(int minCapacity) {
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

查找函数

 //根据元素查找相应下标

public int indexOf(Object o) {
        return indexOf(o, 0);
    }

	//查找对应元素下标
	//index 开始下标，从index下标所在位置开始向下查找
    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;
        }
        //查找失败返回-1
        return -1;
    }

删除函数

//根据元素删除数组相应元素
//先获取元素对应下标，然后删除对应下标元素
public synchronized boolean removeElement(Object obj) {
        modCount++;
        int i = indexOf(obj);
        if (i >= 0) {
            removeElementAt(i);
            return true;
        }
        return false;
    }


 public synchronized void removeElementAt(int index) {
        modCount++;
     //对index进行检验，如果大于数组实际元素数量，报越界异常
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
     //检验index是否小于0，小于0报越界异常
        else if (index < 0) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
     //将index下标后面的元素集体向前移动1下标，并将最后一位元素（elementData[--elementCount]）设null
        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 */
    }