ArrayList简介

ArrayList简介

    ArrayList是基于数组实现的，是一个动态数组，其容量能自动增长，类似于C语言中的动态申请内存，动态增长内存。

    ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类，也可以使用concurrent并发包下的CopyOnWriteArrayList类。

    ArrayList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了RandomAccess接口，支持快速随机访问，实际上就是通过下标序号进行快速访问，实现了Cloneable接口，能被克隆。

ArrayList源码剖析

    ArrayList的源码如下（加入了比较详细的注释）：

[java] view plaincopy

package java.util;    

   

public class ArrayList<E> extends AbstractList<E>    

        implements List<E>, RandomAccess, Cloneable, java.io.Serializable    

{    

    // 序列版本号    

    private static final long serialVersionUID = 8683452581122892189L;    

   

    // ArrayList基于该数组实现，用该数组保存数据   

    private transient Object[] elementData;    

   

    // ArrayList中实际数据的数量    

    private int size;    

   

    // ArrayList带容量大小的构造函数。    

    public ArrayList(int initialCapacity) {    

        super();    

        if (initialCapacity < 0)    

            throw new IllegalArgumentException("Illegal Capacity: "+    

                                               initialCapacity);    

        // 新建一个数组    

        this.elementData = new Object[initialCapacity];    

    }    

   

    // ArrayList无参构造函数。默认容量是10。    

    public ArrayList() {    

        this(10);    

    }    

   

    // 创建一个包含collection的ArrayList    

    public ArrayList(Collection<? extends E> c) {    

        elementData = c.toArray();    

        size = elementData.length;    

        if (elementData.getClass() != Object[].class)    

            elementData = Arrays.copyOf(elementData, size, Object[].class);    

    }    

   

   

    // 将当前容量值设为实际元素个数    

    public void trimToSize() {    

        modCount++;    

        int oldCapacity = elementData.length;    

        if (size < oldCapacity) {    

            elementData = Arrays.copyOf(elementData, size);    

        }    

    }    

   

   

    // 确定ArrarList的容量。    

    // 若ArrayList的容量不足以容纳当前的全部元素，设置 新的容量=“(原始容量x3)/2 + 1”    

    public void ensureCapacity(int minCapacity) {    

        // 将“修改统计数”+1，该变量主要是用来实现fail-fast机制的    

        modCount++;    

        int oldCapacity = elementData.length;    

        // 若当前容量不足以容纳当前的元素个数，设置 新的容量=“(原始容量x3)/2 + 1”    

        if (minCapacity > oldCapacity) {    

            Object oldData[] = elementData;    

            int newCapacity = (oldCapacity * 3)/2 + 1;    

            //如果还不够，则直接将minCapacity设置为当前容量  

            if (newCapacity < minCapacity)    

                newCapacity = minCapacity;    

            elementData = Arrays.copyOf(elementData, newCapacity);    

        }    

    }    

   

    // 添加元素e    

    public boolean add(E e) {    

        // 确定ArrayList的容量大小    

        ensureCapacity(size + 1);  // Increments modCount!!    

        // 添加e到ArrayList中    

        elementData[size++] = e;    

        return true;    

    }    

   

    // 返回ArrayList的实际大小    

    public int size() {    

        return size;    

    }    

   

    // ArrayList是否包含Object(o)    

    public boolean<