ArrayList和Vector

前言

今天阅读ArrayList和Vector的源码,了解其底层结构和扩容机制

首先,需要知道的是

  • ArrayList和Vector底层都是可变数组实现
  • ArrayList非线程安全,Vector是线程安全的

对比一下ArrayList和Vector的常量

public class ArrayList<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // 序列版本号
    private static final long serialVersionUID = 8683452581122892189L;

    // 默认大小为10
    private static final int DEFAULT_CAPACITY = 10;

    // 空的缓存数组
    private static final Object[] EMPTY_ELEMENTDATA = {};

    // 缓存数组没有指定大小时 容量大小为空
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    // 底层实现方式 其实就是通过缓存数组 随时扩充容量 这里使用transient关键字 表示不参与ArrayList的序列化 原因每当ArrayList类序列化和反序列化时会分别调用writeObject和readObject方法读写相关数据 这样避免了缓存数组中存在多余的无用空间 避免占用内存
    transient Object[] elementData;

    // 数组的实际大小
    private int size;
}
public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // 缓存数组
    protected Object[] elementData;

    // 缓存数组中实际容量大小
    protected int elementCount;

    // 自定义的容量增长量
    protected int capacityIncrement;

    // 序列化版本号
    private static final long serialVersionUID = -2767605614048989439L;
}

总结一下,ArrayList和Vector的底层都是通过缓存数组来实现的

ArrayList的elementData使用transient关键字修饰,不参与对象的序列化

而Vector的elelmentData没有参与对象的序列化,至于原因,网上说是因为重写了writeObject方法,因为Vector本质就是线程安全的,我不是很理解,希望有大佬再解释一下

对比构造函数

// 无参构造 elementData默认为空数组
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

// 给定初始大小的构造器
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

// 将已有的集合塞入构造
public ArrayList(Collection<? extends E> c) {
    Object[] a = c.toArray();
    if ((size = a.length) != 0) {
        if (c.getClass() == ArrayList.class) {
            elementData = a;
        } else {
            elementData = Arrays.copyOf(a, size, Object[].class);
        }
    } else {
        // replace with empty array.
        elementData = EMPTY_ELEMENTDATA;
    }
}
// 无参构造 初始化容量大小为10
public Vector() {
    this(10);
}

// 给定初始容量
public Vector(int initialCapacity) {
    this(initialCapacity, 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;
}

// 将已有的集合塞入
public Vector(Collection<? extends E> c) {
    Object[] a = c.toArray();
    elementCount = a.length;
    if (c.getClass() == ArrayList.class) {
        elementData = a;
    } else {
        elementData = Arrays.copyOf(a, elementCount, Object[].class);
    }
}

对比而言,Vector的构造具有更多的自主性,开发者可以限定扩容时的增长值

扩容机制

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

当ArrayList添加元素时,会先将当前实际元素容量和缓存数组容量做对比,大小不够时则考虑扩容

public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}

private void ensureCapacityHelper(int minCapacity) {
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

当Vector添加元素时,同ArrayList,容量不够则考虑扩容

其中,ArrayList多出的代码主要是因为Vector在无参构造时,默认初始化了10个空间,而ArrayList在添加第一个元素时,若缓存数组容量为默认值(空数组),则也给一个初始化的大小(10)

另外,Vector的add函数加上了同步锁,保证了线程的安全性

ArrayList扩容细节

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

一目了然,newCapcity = oldCapcity + ( oldCapcity >> 1 )

进行1.5倍扩容 若初始化空间为10 那么容量大小变化就为 10 -> 15 -> 22 -> 33 -> …

Vector扩容细节

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

Vector中,若开发者没有自定义增长容量,则按2倍扩容,否则每次在当前容量的基础上加上开发者自定义的增长容量

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

Bruce_Zhang61

给萌新一点鼓励吧!

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

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

打赏作者

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

抵扣说明:

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

余额充值