java ArrayList与Vector
Posted StubbornAnt
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java ArrayList与Vector相关的知识,希望对你有一定的参考价值。
本文基于JDK1.7
Vector与ArrayList
- Vector用同步实现了线程安全,ArrayList是线程不安全的,但是可以通过
Collections.synchronizedList(list)
来实现线程安全,不要求线程安全的场景用ArrayList效率更高 - Vector与ArrayList一样是一种可以根据需要自动伸缩的列表,它们都是基于数组实现的,加入了自动扩容机制
- Vector在初始化时除了提供initialCapacity外还可以额外提供capacityIncrement参数,从而在扩容时ArrayList一般会扩展到原来的1.5倍,而Vector在capacityIncrement不为零时会扩展capacityIncrement个元素
- 对Vector与ArrayList相同,在批量插入元素前,调整列表的容量到合理值,可以避免频繁的扩容引起的开销
- Vector是一个比较老的类,为了适配新的List接口对许多原有方法进行了包装,使得其代码较为臃肿,例如:
public synchronized boolean add(E e)
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
public synchronized void addElement(E obj)
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = obj;
- 在序列化方面,Vector只提供了WriteObject方法,没有提供ReadObject方法,没有完全实现定制化
java中一个类实现了Seriaizable就可以实现序列化,ArrayList中保存元素的数组被声明为transient,即elementData数组不会被默认的序列化写入到输出中。ArrayList实现了ReadObject和WriteObject两个方法来进行定制的序列化。这样做的优势在于elementData数组中可能存在很大的空间是没有元素的,如果在序列化过程中这部分也被序列化会耗费大量的资源,因此ArrayList定制序列化,writeObject时只输出实体元素。在对端恢复ArrayList时,ReadObject先确定数组大小,然后将元素拷贝到对应数组中去,避免了添加元素时频繁的扩容,提高了效率
private transient Object[] elementData;
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);
// Write out all elements in the proper order.
for (int i=0; i<size; i++)
s.writeObject(elementData[i]);
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException
elementData = EMPTY_ELEMENTDATA;
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in capacity
s.readInt(); // ignored
if (size > 0)
// be like clone(), allocate array based upon size not capacity
ensureCapacityInternal(size);
Object[] a = elementData;
// Read in all elements in the proper order.
for (int i=0; i<size; i++)
a[i] = s.readObject();
Vector全部源码
- Vector的多数方法实现机制与ArrayList是相同的,只是在方法上添加了synchronized约束
- 由于Vector比List接口出现要早,很多方法名比较长如addElement等,为了适配新的接口List,又添加了许多很类似的方法
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;
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(int initialCapacity)
this(initialCapacity, 0);
public Vector()
this(10);
public Vector(Collection<? extends E> c)
elementData = c.toArray();
elementCount = elementData.length;
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
public synchronized void copyInto(Object[] anArray)
System.arraycopy(elementData, 0, anArray, 0, elementCount);
public synchronized void trimToSize()
modCount++;
int oldCapacity = elementData.length;
if (elementCount < oldCapacity)
elementData = Arrays.copyOf(elementData, elementCount);
public synchronized void ensureCapacity(int minCapacity)
if (minCapacity > 0)
modCount++;
ensureCapacityHelper(minCapacity);
private void ensureCapacityHelper(int minCapacity)
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
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);
private static int hugeCapacity(int minCapacity)
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
public synchronized void setSize(int newSize)
modCount++;
if (newSize > elementCount)
ensureCapacityHelper(newSize);
else
for (int i = newSize; i < elementCount; i++)
elementData[i] = null;
elementCount = newSize;
public synchronized int capacity()
return elementData.length;
public synchronized int size()
return elementCount;
public synchronized boolean isEmpty()
return elementCount == 0;
public Enumeration<E> elements()
return new Enumeration<E>()
int count = 0;
public boolean hasMoreElements()
return count < elementCount;
public E nextElement()
synchronized (Vector.this)
if (count < elementCount)
return elementData(count++);
throw new NoSuchElementException("Vector Enumeration");
;
public boolean contains(Object o)
return indexOf(o, 0) >= 0;
public int indexOf(Object o)
return indexOf(o, 0);
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 int lastIndexOf(Object o)
return lastIndexOf(o, elementCount - 1);
public synchronized int lastIndexOf(Object o, int index)
if (index >= elementCount)
throw new IndexOutOfBoundsException(index + " >= " + elementCount);
if (o == null)
for (int i = index; i >= 0; i--)
if (elementData[i] == null)
return i;
else
for (int i = index; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
return -1;
public synchronized E elementAt(int index)
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
return elementData(index);
public synchronized E firstElement()
if (elementCount == 0)
throw new NoSuchElementException();
return elementData(0);
public synchronized E lastElement()
if (elementCount == 0)
throw new NoSuchElementException();
return elementData(elementCount - 1);
public synchronized void setElementAt(E obj, int index)
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
elementData[index] = obj;
public synchronized void removeElementAt(int index)
modCount++;
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);
elementCount--;
public synchronized void insertElementAt(E obj, int index)
modCount++;
if (index > elementCount)
throw new ArrayIndexOutOfBoundsException(index + " > " + elementCount);
ensureCapacityHelper(elementCount + 1);
System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
elementData[index] = obj;
elementCount++;
public synchronized void addElement(E obj)
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = obj;
public synchronized boolean removeElement(Object obj)
modCount++;
int i = indexOf(obj);
if (i >= 0)
removeElementAt(i);
return true;
return false;
public synchronized void removeAllElements()
modCount++;
// Let gc do its work
for (int i = 0; i < elementCount; i++)
elementData[i] = null;
elementCount = 0;
public synchronized Object clone()
try
@SuppressWarnings("unchecked")
Vector<E> v = (Vector<E>) super.clone();
v.elementData = Arrays.copyOf(elementData, elementCount);
v.modCount = 0;
return v;
catch (CloneNotSupportedException e)
// this shouldn't happen, since we are Cloneable
throw new InternalError();
public synchronized Object[] toArray()
return Arrays.copyOf(elementData, elementCount);
@SuppressWarnings("unchecked")
public synchronized <T> T[] toArray(T[] a)
if (a.length < elementCount)
return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
System.arraycopy(elementData, 0, a, 0, elementCount);
if (a.length > elementCount)
a[elementCount] = null;
return a;
// Positional Access Operations
@SuppressWarnings("unchecked")
E elementData(int index)
return (E) elementData[index];
public synchronized E get(int index)
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
public synchronized E set(int index, E element)
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
public synchronized boolean add(E e)
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
public boolean remove(Object o)
return removeElement(o);
public void add(int index, E element)
insertElementAt(element, index);
public synchronized E remove(int index)
modCount++;
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
E oldValue = elementData(index);
int numMoved = elementCount - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index + 1, elementData, index, numMoved);
elementData[--elementCount] = null; // Let gc do its work
return oldValue;
public void clear()
removeAllElements();
// Bulk Operations
public synchronized boolean containsAll(Collection<?> c)
return super.containsAll(c);
public synchronized boolean addAll(Collection<? extends E> c)
modCount++;
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityHelper(elementCount + numNew);
System.arraycopy(a, 0, elementData, elementCount, numNew);
elementCount += numNew;
return numNew != 0;
public synchronized boolean removeAll(Collection<?> c)
return super.removeAll(c);
public synchronized boolean retainAll(Collection<?> c)
return super.retainAll(c);
public synchronized boolean addAll(int index, Collection<? extends E> c)
modCount++;
if (index < 0 || index > elementCount)
throw new ArrayIndexOutOfBoundsException(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityHelper(elementCount + numNew);
int numMoved = elementCount - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew, numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
elementCount += numNew;
return numNew != 0;
public synchronized boolean equals(Object o)
return super.equals(o);
public synchronized int hashCode()
return super.hashCode();
public synchronized String toString()
return super.toString();
public synchronized List<E> subList(int fromIndex, int toIndex)
return Collections.synchronizedList(super.subList(fromIndex, toIndex), this);
protected synchronized void removeRange(int fromIndex, int toIndex)
modCount++;
int numMoved = elementCount - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved);
// Let gc do its work
int newElementCount = elementCount - (toIndex - fromIndex);
while (elementCount != newElementCount)
elementData[--elementCount] = null;
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();
public synchronized ListIterator<E> listIterator(int index)
if (index < 0 || index > elementCount)
throw new IndexOutOfBoundsException("Index: " + index);
return new ListItr(index);
public synchronized ListIterator<E> listIterator()
return new ListItr(0);
public synchronized Iterator<E> iterator()
return new Itr();
private class Itr implements Iterator<E>
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext()
// Racy but within spec, since modifications are checked
// within or after synchronization in next/previous
return cursor != elementCount;
public E next()
synchronized (Vector.this)
checkForComodification();
int i = cursor;
if (i >= elementCount)
throw new NoSuchElementException();
cursor = i + 1;
return elementData(lastRet = i);
public void remove()
if (lastRet == -1)
throw new IllegalStateException();
synchronized (Vector.this)
checkForComodification();
Vector.this.remove(lastRet);
expectedModCount = modCount;
cursor = lastRet;
lastRet = -1;
final void checkForComodification()
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
final class ListItr extends Itr implements ListIterator<E>
ListItr(int index)
super();
cursor = index;
public boolean hasPrevious()
return cursor != 0;
public int nextIndex()
return cursor;
public int previousIndex()
return cursor - 1;
public E previous()
synchronized (Vector.this)
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
cursor = i;
return elementData(lastRet = i);
public void set(E e)
if (lastRet == -1)
throw new IllegalStateException();
synchronized (Vector.this)
checkForComodification();
Vector.this.set(lastRet, e);
public void add(E e)
int i = cursor;
synchronized (Vector.this)
checkForComodification();
Vector.this.add(i, e);
expectedModCount = modCount;
cursor = i + 1;
lastRet = -1;
以上是关于java ArrayList与Vector的主要内容,如果未能解决你的问题,请参考以下文章
深入解析 Java集合类ArrayList与Vector的区别