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 workfor (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开始有的类.