Java ArrayList vs. Vector

ゝ一纸荒年。 2022-12-18 12:56 108阅读 0赞

ArrayList 和 Vector 的比较是面试中一个常见的问题，要想回答得好，还需要下点工夫，本文来总结下它们之间的相似以及区别。

# 相似点 #

先看下相似点。首先我们都是由数组来实现的，并且它们都实现了 RandomAccess 接口，因此支持快速随机访问，也就是通过索引快速定位元素。因此从本质上来说，它们之间是可以能通用的。

# 区别 #

Vector 现在很少用到，这是因为它与 ArrayList 之间的区别造成的。

## 线程安全 ##

Vector 是线程安全的类，因为它的大部分方法都是通过 synchronized 关键字进行同步的，例如 `add()` 方法

public synchronized boolean add(E e) { 
    		// ...
            return true;
        }

然而 ArrayList 并不是线程安全的类，它的方法没有 synchronized 关键字，也没有通过锁来保证线程安全。

大部分时候，我们都不需要考虑线程安全，因此我们经常使用 ArrayList 而不是 Vector ，毕竟同步是需要付出一定的性能代价的。然而如果一旦考虑线程安全问题，我们还是可以使用 Vector 的。

虽然 ArrayList 不是线程安全的，但是我们还是有办法使之成为线程安全，例如我们可以在某个对象上进行同步，然后再操作 ArrayList 对象，例如下面的添加元素的操作

synchronized (object) { 
    	arraylist.add("element");
    }

但是这似乎显得比较笨拙，我们还可以在创建 ArrayList 对象时，使用 `Collections.synchronizedList()` 来创建一个 ArrayList 的包装类对象

List list = Collections.synchronizedList(new ArrayList());

这样是不是就方便很多。

ArrayList 还有一个线程安全的版本 CopyOnWriteArrayList，它的修改方法，例如 `add()`, `set()` 都是在底层数组的拷贝上进行的，但是 CopyOnWriteArrayList 通常用于遍历操作的数量远远大于修改的数量的情况下。

## 扩容方式 ##

首先看下 ArrayList 的扩容方式

private void grow(int minCapacity) { 
            int oldCapacity = elementData.length;
            // 扩容0.5倍大小
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            elementData = Arrays.copyOf(elementData, newCapacity);
        }

ArrayList 的基本扩容策略是先扩容0.5倍，然后再根据实际需要进行调整。

再来看下 Vector 扩容方式

private void grow(int minCapacity) { 
            int oldCapacity = elementData.length;
            // 使用自定义扩容方式或者扩容1倍
            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);
        }

`capacityIncrement` 表示扩容时的增长量，这个是在构造函数时赋值的，默认是0。

因此，Vector 的扩容策略是，如果指定的扩容的大小，那么就使用自定义的策略，否则扩容一倍。再根据需要进行调整。

通常，我们并不知道设置扩容量为多大，才最合适，因此都不会在构造函数中设置这个值，那么这个值默认就是0。因此 Vector 的基本扩容策略是扩容一倍。

我们并不能一概而论地说扩容策略谁优谁劣，要看实际情况而定的。

## 序列化 ##

首先看下 ArrayList 的序列化

// tansient 修饰的数组，默认不会执行序列化操作
    	transient Object[] elementData;
    	
        private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException{ 
            int expectedModCount = modCount;
            // 执行默认的序列化操作
            s.defaultWriteObject();
    		
    		// 保存容量
            s.writeInt(size);
    		
    		// 保存数组元素
            for (int i=0; i<size; i++) { 
                s.writeObject(elementData[i]);
            }
    
            if (modCount != expectedModCount) { 
                throw new ConcurrentModificationException();
            }
        }

ArrayList 背后的数组被 `transient` 关键字修饰，那么它就不会执行默认序列化操作，因此在 `writeObject()` 方法中要手动进行保存操作，为什么这样操作呢？

因为数组中可以存在一些空元素，如果使用默认序列化机制来保存数组的元素，那么这些空元素是会被保存的。那么在反序列化时，会额外为这些空元素分配不必须的空间。如此看来，ArrayList 的序列化操作还是比较高效的嘛。

我们再来看下 Vector 的序列化操作

protected Object[] elementData;
    	
        private void writeObject(java.io.ObjectOutputStream s)
                throws java.io.IOException { 
            final java.io.ObjectOutputStream.PutField fields = s.putFields();
            final Object[] data;
            synchronized (this) { 
                fields.put("capacityIncrement", capacityIncrement);
                fields.put("elementCount", elementCount);
                data = elementData.clone();
            }
            fields.put("elementData", data);
            s.writeFields();
        }

首先我们注意到 Vector 背后的数组没有使用 `transient` 关键字修饰，但是它还是定义了 `writeObject()` 方法来自己处理序列化操作。可以看到，Vector 序列化，保存了数组的完整的克隆版本，其中就包括一些空元素。那么反序列化时，可以会浪费额外的空间。

因此在序列化问题上，ArrayList 可能比 Vector 更高效点。

# 结束 #

在平时的工作中，Vector 很少用到，但是并不是无用武之地，只是大部分时候我们不需要线程安全，因此 ArrayList 占据主流。并且在需要线程安全时，ArrayList 也提供了线程安全的方式，因此 Vector 渐渐退出历史舞台。