新手读源码__Vector，扩容不单单是2倍

墨蓝 2022-05-25 03:43 146阅读 0赞

## 前言 ##

上一次分析集合的源码还是4.20，一晃半个月过去了，由于hashMap中遇到了红黑树，于是我决定去看下二叉排序树，AVL，B，B+，RB-Tree，这几种树，然后这10几天中因为《深入理解JVM》到了，也基本上都在看，看到了200页。后悔当时数据结构没好好学，AVL之流都没咋学。不过放下负担，好好去学才是正解，下面进入正题Vector

## 开篇疑问 ##

在我看过的资料中，或者博文中，都会简单的说，ArrayList和Vector的区别在于ArrayList是1.5倍扩容Vector是2倍扩容，还有就是线程安全，今天看了源码的我，才发现，原来Vectory还可以支持定量增容

## 维护的属性 ##

维护的属性很简单，主要有三个

protected Object[] elementData; //储存对象的数组
    protected int elementCount;     // 对象的计数
    protected int capacityIncrement;    // 指定的增量大小

## 构造方法 ##

1、无参数构造，默认容量为10，不提供增量大小->0

public Vector() {
            this(10);
        }

2、提供初始容量，不提供增量大小->0

public Vector(int initialCapacity) {
            this(initialCapacity, 0);
        }

3、提供初始容量和增量大小，检测增量值要大于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;
        }

构造方法通过逐级调用，从而达到默认值的效果

## add增加 ##

public synchronized boolean add(E e) {
            modCount++;
            add(e, elementData, elementCount);
            return true;
        }

private void add(E e, Object[] elementData, int s) {
            if (s == elementData.length)
                elementData = grow();
            elementData[s] = e;
            elementCount = s + 1;
        }

我们可以看到，当容量满了的时候就会进行扩容操作grow，扩容是比较有意思的地方

## 扩容 ##

// 将旧容量+1，作为参数传递
        private Object[] grow() {
            return grow(elementCount + 1);
        }
    
        //数组复制，查看一下newCapacity( )
        private Object[] grow(int minCapacity) {
            return elementData = Arrays.copyOf(elementData,
                                               newCapacity(minCapacity));
        }
    
        private int newCapacity(int minCapacity) {
            // overflow-conscious code
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                             capacityIncrement : oldCapacity);
            if (newCapacity - minCapacity <= 0) {
                if (minCapacity < 0) // overflow
                    throw new OutOfMemoryError();
                return minCapacity;
            }
            return (newCapacity - MAX_ARRAY_SIZE <= 0)
                ? newCapacity
                : hugeCapacity(minCapacity);
        }

真正的扩容就是newCapacity()这个函数，首先它判断增量是否大于0，也就是判断是否有最初设定的增量大小，如果有增量大小，新容量=增量+旧容量，如果没有增量则容量变为原来的两倍，同时确保容量不超过最大容量MAX\_\_ARRAY\_\_SIZE

## 删除remove ##

public boolean remove(Object o) {
            return removeElement(o);
        }
    
        public synchronized boolean removeElement(Object obj) {
            modCount++;
            int i = indexOf(obj);
            if (i >= 0) {
                removeElementAt(i);
                return true;
            }
            return false;
        }
    
        // 找到对象的索引
        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;
            }
            return -1;
        }
    
        // 移除并复制原来的数组
        public synchronized void removeElementAt(int index) {
            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);
            }
            modCount++;
            elementCount--;
            elementData[elementCount] = null; /* to let gc do its work */
        }

需要看一下这个复制的API

void java.lang.System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

它的意思是，从原数组的某一个位置开始复制到新数组的某一个元素，总长度是length，它是由Hotspot虚拟机来实现的。同样ArrayList中，也是用这种方法是实现的，叫fastRemove()

## 遍历 ##

package test;
    
    import java.util.Enumeration;
    import java.util.Iterator;
    import java.util.Vector;
    
    public class Test 
    {
        public static void main(String[] args)
        {
            Vector<String> vector = new Vector();
            vector.add("1");
            vector.add("2");
            vector.add("3");
            // index访问
            for (int i = 0; i < vector.size(); i++) {
                System.out.println(vector.get(i));
            }
    
            // for循环
            for (String string : vector) {
                System.out.println(string);
            }
    
            //迭代器
            Iterator<String> it = vector.iterator();
            while (it.hasNext()) {
                System.out.println(it.next());
            }
    
            // Enumeration
            Enumeration<String> enumeration = vector.elements();
            while (enumeration.hasMoreElements()) {
                System.out.println(enumeration.nextElement());
            }
        }
    }

之前我只知道iterator迭代器，今天才发现原来还有枚举，查看这个接口的定义

## Enumeration ##

public interface Enumeration<E> {
        boolean hasMoreElements();
        E nextElement();
        default Iterator<E> asIterator() {
            return new Iterator<>() {
                @Override public boolean hasNext() {
                    return hasMoreElements();
                }
                @Override public E next() {
                    return nextElement();
                }
            };
        }

这个接口主要是访问，并不提供删除操作，但是也可以通过它来返回一个iterator迭代器，也就是asIterator方法

## 总结 ##

总的来说，它的重点在于扩容提供的增量扩容，可以提供固定的增长量，然后还有一个就是认识了下Enumberation这个接口，它的内部实现还是不难的，所以到这里就算是了解了