ArrayList、Vector

ArrayList和Vector都是有序的数组集合,内部是数组的实现。

一、ArrayList

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable

1、核心结构

Object[] elementData；//存储列表元素的数组
int size； //数组中有效元素的个数

2、增、删、改、查

2.1、增加元素

public boolean add(E e) {
	ensureCapacityInternal(size + 1);  //检查是否需要增加数组的容量
	elementData[size++] = e; //设置元素
	return true;
}
public void add(int index, E element) {
	rangeCheckForAdd(index); //检查数组下标是否越界

	ensureCapacityInternal(size + 1);  //检查是否需要增加数组的容量
	System.arraycopy(elementData, index, elementData, index + 1,size - index); //移动数组
	elementData[index] = element; //设置元素
	size++;
}

public boolean addAll(Collection<? extends E> c) {
	Object[] a = c.toArray(); //转换为数组
	int numNew = a.length;
	ensureCapacityInternal(size + numNew);  // 检查是否需要增加数组的容量
	System.arraycopy(a, 0, elementData, size, numNew);//将collection中的元素拷贝到list中
	size += numNew;
	return numNew != 0;
}
public boolean addAll(int index, Collection<? extends E> c) {
	rangeCheckForAdd(index); //检查数组下标是否越界

	Object[] a = c.toArray();
	int numNew = a.length;
	ensureCapacityInternal(size + numNew);  // 检查是否需要增加数组的容量

	int numMoved = size - index;
	if (numMoved > 0)
		System.arraycopy(elementData, index, elementData, index + numNew,
						 numMoved);

	System.arraycopy(a, 0, elementData, index, numNew);
	size += numNew;
	return numNew != 0;
}

2.2、删除元素

public E remove(int index) {
	rangeCheck(index);  //检查数组下标是否越界
	E oldValue = elementData(index); //移除的元素值

	fastRemove(index); //
	return oldValue;
}

public boolean remove(Object o) {
	if (o == null) { //null元素
		for (int index = 0; index < size; index++)
			if (elementData[index] == null) {
				fastRemove(index);
				return true;
			}
	} else {
		for (int index = 0; index < size; index++)
			if (o.equals(elementData[index])) { //通过equals判断元素是否相等
				fastRemove(index);
				return true;
			}
	}
	return false;
}
private void fastRemove(int index) {
	modCount++;
	int numMoved = size - index - 1;
	if (numMoved > 0)
		System.arraycopy(elementData, index+1, elementData, index,
						 numMoved);
	elementData[--size] = null; // clear to let GC do its work
}
public void clear() {
	modCount++;

	// clear to let GC do its work
	for (int i = 0; i < size; i++)
		elementData[i] = null;

	size = 0;
}

2.3、更换元素

public E set(int index, E element) {
	rangeCheck(index); //检查数组下标是否越界

	E oldValue = elementData(index); 
	elementData[index] = element; //替换元素
	return oldValue;
}

2.4、查询元素

public int indexOf(Object o) {
	if (o == null) {
		for (int i = 0; i < size; i++)
			if (elementData[i]==null)
				return i;
	} else {
		for (int i = 0; i < size; i++)
			if (o.equals(elementData[i])) //使用equals判断
				return i;
	}
	return -1;
}

public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--) //倒序查询
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
}

public E get(int index) {
	rangeCheck(index);

	return elementData(index);
}

public boolean contains(Object o) {
	return indexOf(o) >= 0;
}

@SuppressWarnings("unchecked")
E elementData(int index) {
	return (E) elementData[index];
}

3、多线程下使用ArrayList

ArrayList是非线程安全的,因此在多线程环境中操作ArrayList要加同步机制。

3.1、Collections.synchronizedList(list); 将ArrayList包装成SynchronizedList.

static class SynchronizedList<E>
	extends SynchronizedCollection<E>
	implements List<E> {
	private static final long serialVersionUID = -7754090372962971524L;

	final List<E> list;

	SynchronizedList(List<E> list) {
		super(list);
		this.list = list;
	}
	SynchronizedList(List<E> list, Object mutex) {
		super(list, mutex);
		this.list = list;
	}
     //读取
	public E get(int index) {
		synchronized (mutex) {return list.get(index);}
	}
	 //设值
	public E set(int index, E element) {
		synchronized (mutex) {return list.set(index, element);}
	}
	 //添加
	public void add(int index, E element) {
		synchronized (mutex) {list.add(index, element);}
	}
	 //删除
	public E remove(int index) {
		synchronized (mutex) {return list.remove(index);}
	}

不管是读取还是修改，都加了同步锁。所以性能比较低。

3.2、CopyOnWriteArrayList

核心结构：

final transient ReentrantLock lock = new ReentrantLock();//同步锁，只在add、remove时需要添加锁机制，读不需要同步
private transient volatile Object[] array; //数组容器，容器中的都是实际存放的元素,即array.length=size();

//添加元素 ,同步添加元素操作，保证数组中元素顺序的正确性
public boolean add(E e) {
	final ReentrantLock lock = this.lock;
	lock.lock();
	try {
		Object[] elements = getArray();
		int len = elements.length;
		Object[] newElements = Arrays.copyOf(elements, len + 1); //复制一个新数组，先将元素添加到副本数组中，不影响原来的数组容器
		newElements[len] = e;//设置元素
		setArray(newElements);//将原容器的引用指向新的容器, 即array = newElements;
		return true;
	} finally {
		lock.unlock();
	}
}

//读取元素
public E get(int index) {
	return array[index];
}

注意：CopyOnWriteList的性能要高于Collections.synchronizedList(list)

4、迭代时修改结构

//1.错误的处理方式，导致循环时获取的元素不正确
for (int i = 0; i < list.size(); i++) {
	System.out.println(list.get(i));
	if (list.get(i).equals("1")) {
		list.remove("1");
	}
}


// 2、通过迭代器添加或删除元素
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
	String item = listIterator.next();
	if (item.equals("1")) {
		listIterator.remove();
	}
}

二、Vector

public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable

1、核心结构

protected Object[] elementData; //数组容器
protected int elementCount; //有效元素个数
protected int capacityIncrement; //当容器满时，容器自动增加的量

2、Vector是线程安全的

增删改查方法都使用了synchronized关键字

3、从JDK1.0开始有的类，ArrayList是JDK1.2开始有的类.