Java基础-源码分析-ArrayList/Vector

Java工程师知识树 / Java基础

---

首先看下ArrayList的源码分析，Vector与ArrayList区别在与方法层面加上了synchronized。

ArrayList特点

ArrayList是List接口的可变数组非同步实现，并允许包括null在内的所有元素。底层使用数组实现。

ArrayList结构

Java继承与实现的接口情况为：

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

• List：用来存储有序的、可重复的数据。

• AbstractList：是个抽象类，抽象类一般用来提取一些共有的属性，AbstractList包含了ArrayList，LinkedList，Vector等集合类共同的属性。AbstractList有add()，get()，set()，remove()等方法。

• RandomAccess：是一个标志接口，表明实现这个接口的 List 集合是支持快速随机访问的。在ArrayList中，快速随机访问为可以通过元素的序号快速获取元素对象。常用实现RandmoAccess接口的集合类有ArrayList，ArrayDeque。

• Cloneable：ArrayList 实现了Cloneable接口，并覆盖了函数clone()，能被克隆。

• Serializable：实现java.io.Serializable 接口后ArrayList支持序列化，能通过序列化去传输。

ArrayList属性

    //序列号
    private static final long serialVersionUID = 8683452581122892189L;
 
    //默认初始容量
    private static final int DEFAULT_CAPACITY = 10;
 
    //一个空数组，当用户指定ArrayList容量为0时，返回该数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
 
      /**
     * 一个空数组实例
     * - 当用户没有指定 ArrayList 的容量时(即调用无参构造函数)，返回的是该数组==>刚创建一个 ArrayList 时，其内数据量为 0。
     * - 当用户第一次添加元素时，该数组将会扩容，变成默认容量为 10(DEFAULT_CAPACITY) 的一个数组===>通过  ensureCapacityInternal() 实现
     * 它与 EMPTY_ELEMENTDATA 的区别就是：该数组是默认返回的，而后者是在用户指定容量为 0 时返回
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
 
    /*
      *当前数据对象存放地方，当前对象不参与序列化
      *这个关键字最主要的作用就是当序列化时，被transient修饰的内容将不会被序列 化
     */
    transient Object[] elementData; // non-private to simplify nested class access
 
    //ArrayList实际存储的数据数量
    private int size;
 
    /**
      *继承于AbstractList集合数组修改次数的标识
      */
    protected transient int modCount = 0;
 

ArrayList初始化容量为10，elementData.length=10,而size=0。

ArrayList构造函数

/**
 * 创建一个初试容量的、空的ArrayList
 * @param  initialCapacity  初始容量
 * @throws IllegalArgumentException 当初试容量值非法(小于0)时抛出
 */
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                initialCapacity);
    }
}

/**
 * 无参构造函数：
 * 创建一个 空的 ArrayList，此时其内数组缓冲区 elementData = {}, 长度为 0
 * 当元素第一次被加入时，扩容至默认容量 10
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
 * 创建一个包含collection的ArrayList
 * @param c 要放入 ArrayList 中的集合，其内元素将会全部添加到新建的 ArrayList 实例中
 * @throws NullPointerException 当参数 c 为 null 时抛出异常
 */
public ArrayList(Collection c) {
    //把集合传化成Object[]数组
    elementData = c.toArray();
    //转化后的数组长度赋给当前ArrayList的size,并判断是否为0
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        // c.toArray可能不会返回 Object[]
        if (elementData.getClass() != Object[].class)
            // 若 c.toArray() 返回的数组类型不是 Object[]，则利用 Arrays.copyOf(); 来构造一个大小为 size 的 Object[] 数组
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 替换空数组
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

ArrayList方法分析

类源码方法层面的分析最好的方法是使用Debug一步步走一遍该方法。

add(E e)方法

/**
 * 方法描述：直接添加数据元素到arraylist的尾部
 */
public boolean add(E e) {
    //是否扩容、记录modCount 见下面方法·  
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //把值添加到数组尾部
    elementData[size++] = e;
    return true;
}
----------------------------------------------------------------------

private void ensureCapacityInternal(int minCapacity) {
    //minCapacity=size+1；
    //minCapacity表示如果添加成功后，数组的最小长度
    //如果为无参构造
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //取默认长度和minCapacity的最大值，即10
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //是否扩容
    ensureExplicitCapacity(minCapacity);
}
----------------------------------------------------------------------

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // 如果添加后最小长度大于 数组长度
    if (minCapacity - elementData.length > 0)
        //扩容
        grow(minCapacity);
}
----------------------------------------------------------------------
private void grow(int minCapacity) {
    //获取数组长度
    int oldCapacity = elementData.length;
    //1.5倍扩容
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //1.5倍扩容也不够用
    if (newCapacity - minCapacity < 0)
        //扩容后长度=minCapacity
        newCapacity = minCapacity;
    //简直最大长度
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 复制
    elementData = Arrays.copyOf(elementData, newCapacity);
}

remove(int index)方法

/*
 * 方法描述：根据角标进行remove操作
 */
public E remove(int index) {
    // 1. 对角标越界进行判断
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));//数组下标越界异常
    // 2.modCount自增1
    modCount++;
    // 3.获取到指定下角标位置的数据
    E oldValue = (E) elementData[index];
    // 4.计算需要移动的元素个数
    int numMoved = size - index - 1;
    if (numMoved > 0)
        // 5. 指定角标位置后的元素前移一位，效率低
        System.arraycopy(elementData, index+1, elementData, index,
                numMoved);
    // 6.将size自减1，并将数组末尾置为null，便于垃圾回收
    elementData[--size] = null; // clear to let GC do its work
    // 7.最后将所要删除的数据元素return掉
    return oldValue;
}

/*
 * 二：根据数据元素进行remove操作
 */
public boolean remove(Object o) {
    if (o == 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])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}
----------------------------------------------------------------------
private void fastRemove(int index) {
    // 1.modCount的值自增1
    modCount++;
    // 2.计算需要移动的元素个数
    int numMoved = size - index - 1;
    if (numMoved > 0)
        // 3. 指定角标位置后的元素前移一位
        System.arraycopy(elementData, index+1, elementData, index,
                numMoved);
    // 4.将size自减1，并将数组末尾置为null，便于垃圾回收
    elementData[--size] = null; // clear to let GC do its work
}

iterator方法

/**
 * 以一种合适的排序返回一个iterator到元素的结尾
 */
public Iterator iterator() {
    return new Itr();
}

/**
 * Itr是AbstractList.Itr的优化版本
 * 为什么会报ConcurrentModificationException异常?
 * 1. Iterator 是工作在一个独立的线程中，并且拥有一个 mutex 锁。
 * 2. Iterator 被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，
 * 这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，
 * 3. 所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。
 * 4. 所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。
 * 但你可以使用 Iterator 本身的方法 remove() 来删除对象，
 * 5. Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。
 */
private class Itr implements Iterator {
    int cursor;       // 下一个元素返回的索引
    int lastRet = -1; // 最后一个元素返回的索引  -1 if no such
    int expectedModCount = modCount;

    /**
     * 是否有下一个元素
     */
    public boolean hasNext() {
        return cursor != size;
    }

    /**
     * 返回list中的值
     */
    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();
        int i = cursor;//i当前元素的索引
        if (i >= size)//第一次检查：角标是否越界越界
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)//第二次检查,list集合中数量是否发生变化
            throw new ConcurrentModificationException();
        cursor = i + 1; //cursor 下一个元素的索引
        return (E) elementData[lastRet = i];//最后一个元素返回的索引
    }

    /**
     * 移除集合中的元素
     */
    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            //移除list中的元素
            ArrayList.this.remove(lastRet);
            //由于cursor比lastRet大1，所有这行代码是指指针往回移动一位
            cursor = lastRet;
            //将最后一个元素返回的索引重置为-1
            lastRet = -1;
            //重新设置了expectedModCount的值，避免了ConcurrentModificationException的产生
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }
    /**
     * 检查modCount是否等于expectedModCount
     * 在 迭代时list集合的元素数量发生变化时会造成这两个值不相等
     */
    final void checkForComodification() {
        //当expectedModCount和modCount不相等时，就抛出ConcurrentModificationException
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

fail-fast机制:

fail-fast机制是集合中的一种错误检测机制，我们在操作集合中经常会遇到 java.util.ConcurrentModificationException异常，产生该异常的原因就是fail-fast机制。
java.util.ConcurrentModificationException字面意思为并发修改异常，表现为遍历集合的时候,不允许对集合做更改。

实现：如果在迭代期间计数器被修改，那么hasNext或next将抛出concurrentModificationException
缺点：这种检查是没有同步的情况下进行的，因此可能会看到失效的计数值，而迭代器可能并没有意识到已经发生了修改。这是一种设计上的权衡，从而降低了并发修改操作的检测代码对程序性能带来的影响。

contains方法

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}
----------------------------------------------------------------------
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]))
                return i;
    }
    return -1;
}

可能的并发问题

• add()
  • a、100个元素，可能最后数组长度不到100。
    两个线程并发add，对索引位置5的地方几乎同时赋值，第二个线程会覆盖第一个线程的值，并且size少了1个。
  • b、假设有两个线程在操作同一个ArrayList，线程一执行step1(容量足够)后被挂起，线程二执行add()方法后，线程一被唤醒，这时线程一因为已经不再判断容量是否足够（已经判断过），执行step2就会出现数组越界数组容量检测的并发问题
• remove()
  两个线程有可能会想要删除同一个内容，一个线程先完成的时候第二个线程再删，就找不到这个内容了

---

Vector

Vector 类实现了一个动态数组。和 ArrayList 很相似，但是两者是不同的：

• Vector 是同步访问的，方法层面加上了synchronized。

• Vector 包含了许多传统的方法，这些方法不属于集合框架。通过Vector 扩展了数据结构中的栈的实现，栈(Stack)是Vector的一个子类，它实现了一个标准的后进先出的栈。

Vector 主要用在事先不知道数组的大小，或者只是需要一个可以改变大小的数组的情况。