转载

Vector和ArrayList对比

本文会对 ArrayList 和 Vector 进行分析，为什么会关注这两个类，主要是因为他们拥有相同的继承结构，接下来就来探索下这两个类实现和效率的异同。

继承结构

可以看到， Vector 和 ArrayList 都实现了 List 和 RandomAccess 接口，都继承了 AbstractList 。通过他们的继承结构，大致可以猜测他们在元素的处理上存在很多相同的地方。

存储结构

Vector 和 ArrayList 都使用 Object [] elementData 保存数据，但是不同的 ArrayList 的 elementData 使用 transient 做了标记，这说明 ArrayList 的 elementData 不参与对象序列化的过程。

添加元素

Vector
add(E)
add(int, E)
addElement(E obj)
addAll(Collection<? extends E> c)
addAll(int, Collection<? extends E> c)
insertElementAt(E obj, int )
ArrayList
add(E)
add(int, E)
addAll(Collection<? extends E> c)
addAll(int, Collection<? extends E> c)

在元素的添加上， Vector 和 ArrayList 差不多提供了相同的接口，但是最大的不同是 Vector 提供的接口中，除了 add(int, E) 之外，都是同步接口，但是 add(int, E) 最终会调用同步方法 insertElementAt(E obj, int ) ，故 Vector 添加元素都是同步方法； ArrayList 添加元素的方法都是非同步方法。

访问

Vector
get(int index)
elementAt(int index)
ArrayList
get(int index)

在对元素的随机访问上， Vector 比 ArrayList 多了一个 elementAt(int index) 函数，但是 elementAt(int index) 和 get(int index) 原理是一样的，故可以总结为 Vector 和 ArrayList 在随机访问元素时实现了同样的接口。最大的不同仍然是 Vector 对元素的随机访问是同步的，而 ArrayList 是非同步的。

遍历

ArrayList 提供了 foreach , Iterator 的遍历方式， Vector 除此之外还提供了另外两种遍历方式：

Vector<String> sVector = new Vector<>();
    for (int i = 0 ; i < 5 ; i++) {
		sVector.add("test" + i);
	}
	
	sVector.forEach(new Consumer<String>() {
		@Override
		public void accept(String t) {
			// TODO Auto-generated method stub
			System.out.println(t);	
		}
	});
		
		
	Enumeration<String> enumeration = sVector.elements();
	while (enumeration.hasMoreElements()) {
		System.out.println(enumeration.nextElement());
	}
复制代码

在 Vector 中，这两种方式和使用 Iterator 方式遍历最大的区别是他们不是同步的，主要原因是以上两种遍历方法不会在遍历过程中对集合中的数据进行修改。

扩容

由于使用数组存储元素，在元素不断的增加程中， Vector 和 ArrayList 都需要对数组容量进行增加，在数组容量变化上， Vector 和 ArrayList 选择了不一样的策略。

Vector

private void grow(int minCapacity) {
		// overflow-conscious code
		int oldCapacity = elementData.length;
		int newCapacity = oldCapacity + ((capacityIncrement > 0) ?capacityIncrement : oldCapacity);
		.......
	}
复制代码

在扩容的时候，如果 capacityIncrement > 0 ( caoaciryIncrement 是新建 Vector 时传递的第二个参数，但是在具体使用很少使用这个参数，故大多数情况下 capacityIncrement=0 )，则将容量增加 capacityIncrement ，否则容量直接增加一倍。

ArrayList

private void grow(int minCapacity) {
		// overflow-conscious code
		int oldCapacity = elementData.length;
		int newCapacity = oldCapacity + (oldCapacity >> 1);
		......
	}
复制代码

ArrayList 的扩容很简单，直接在原来容量的基础上增加了50%。

效率究竟差多少

Vector 是线程安全的容器，它的很多方法都使用synchronzied方法进行了修饰，说明要使用Vector实例，需要先获得锁，这一过程比较耗时，但是究竟能耗时多少，是不是比 ArrayList 耗时很多？本文不打算去测试在多线程环境下两者的对比，因为在使用 ArrayList 的时候，大多数场景是单线程的环境，本文就在单线程的环境中对 Vector 和 ArrayList 进行对比，这种对比不是精确的对比，只是对比一下快慢。本文从添加，遍历和随机访问三个方面进行对比。测量的方法比较简单，就是先向集合中添加元素，然后再去遍历元素，最后分别统计添加元素，遍历元素和随机访问的耗时，测试的java环境是jdk1.8.0_181。

Vector

long start = System.currentTimeMillis();
	for (int i = 0 ; i < 500000 ; i++) {
		sVector.add("qiwoo_test_add" + i);
	}
	long end = System.currentTimeMillis();
	System.out.println("vector add time consuming:" + (end - start));

	Iterator<String> iterator = sVector.iterator();
	long visitStart = System.currentTimeMillis();
	while (iterator.hasNext()) {
		String str = iterator.next();
	}
	long visitEnd = System.currentTimeMillis();
	System.out.println("vector visit time consuming:" + (visitEnd -visitStart));
		
	long randAccessStart = System.currentTimeMillis();
	for (int i = 0 ; i < 500000 ; i++) {
		sVector.get(i);
	}
	long randAccessend = System.currentTimeMillis();
	System.out.println("vector random access time consuming:" +(randAccessend - randAccessStart));
复制代码

在我的电脑上，运行的结果如下：

vector add time consuming:95

vector visit time consuming:18

vector random access time consuming:14

ArrayList

long start = System.currentTimeMillis();
	for (int i = 0 ; i < 500000 ; i++) {
		sArray.add("qiwoo_test_add" + i);
	}
	long end = System.currentTimeMillis();
	System.out.println("array add time consuming:" + (end - start));
	
	
	
	Iterator<String> iterator = sArray.iterator();
	long visitStart = System.currentTimeMillis();
	while (iterator.hasNext()) {
		String str = iterator.next();
	}
	long visitEnd = System.currentTimeMillis();
	System.out.println("array visit time consuming:" + (visitEnd -visitStart));
	
	long randAccessStart = System.currentTimeMillis();
	for (int i = 0 ; i < 500000 ; i++) {
		sArray.get(i);
	}
	long randAccessend = System.currentTimeMillis();
	System.out.println("array random access time consuming:" +(randAccessend - randAccessStart));
		
复制代码

在我的电脑上运行结果如下：

array add time consuming:82

array visit time consuming:11

array random access time consuming:5

上面的结果可以发现，在单线程环境下，在元素添加和遍历上， Vector 均比 ArrayList 慢了一些，其中添加元素慢了8%左右，遍历元素慢了64%，随机访问慢了1.8倍，这些数据可能受数据量的不同而不同，但是整体的趋势应该是一致的。

以上测试的时候，数据量为500000，但是实际进行Android开发的过程中产生的数据量比较少，参考下google设计容器时的数量考虑，接下来把数据量设置为1000，看下运行结果的差异

Vector
vector add time consuming:2
vector visit time consuming:1
array random access time consuming:0
ArrayList
array add time consuming:2
array visit time consuming:1
array random access time consuming:0

当数据量到1000时， Vector 和 ArrayList 在元素的添加，遍历和随机访问上已经没有什么性能差异或者说差异很小。

总结

ArrayList 和 Vector 都是java中比较重要的容器，他们都可以存储各种对象，它们有相同的继承结构，提供大致相同的功能，主要的差异点如下：

Vector 是线程安全的容易，可以在并发环境中安全地使用，而 ArrayList 是非线程安全的
ArrayList 进行扩容时增加50%， Vector 提供了扩容时的增量设置，但通常将容量扩大1倍
Vector 可以使用Enumeration和Iterator进行元素遍历， ArrayList 只提供了Iterator的方式
由于使用的线程同步， Vector 的效率比 ArrayList 低

自java1.6之后，为了优化synchronized，java引入了偏向锁，在单线程环境中， Vector 的效率已经被提高了。从刚才的对比也可以发现，在单线程环境中，数据量较少（测试数据量在100000性能差异较小）的情况下， Vector 和 ArrayList 的性能差异已经不明显了。

原文 https://juejin.im/post/5c0091ecf265da614312ca97

正文到此结束