Java基础你要知道的事情------集合框架之ArrayList

本文源码JDK版本是1.7

1.ArrayList是用来存储数据的数据结构线性的，底层是由一个动态数组来维护的，可以动态扩容，然后他是有序的存储什么顺序读取就是什么顺序，可以存储null，可以存储重复的数据，是线程非安全的。

2.ArrayList的继承实现结构图，继承了AbstractList实现了List接口，还有实现了一些其他的需要用到的功能接口如序列化，快速访问等.**

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
/**RandomAccess，Serializable这2个接口都是空的，其实只是起到一个标志的作用，说明这个类支持快速访问，可以进行序列化跟反序列化。
Cloneable接口，表明这个是可以进行浅拷贝的，是可以调用Object.clone()返回该对象的浅拷贝。
什么是浅拷贝呢？
举个例子：
假设x是一个非空对象，应该有：
(x.clone()!=x )==true,也就是说它们不是同一个对象。
(x.clone().getClass()==x.getClass())==true,也就是它们是同一个类型的class，
(x.equals(x.clone()))==true,也就是，逻辑上和内容上，它们应该是相同的。
实现了Cloneable的类应该要满足上面的几个情况。
**/
}

3.ArrayList最基本几个方法

初始化的几个方法

无参数的

public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }

带初始大小的

public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }

带集合参数的

public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        size = elementData.length;
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

ArrayList的源码分析—-add（），add（index，elementData）添加元素

//下面是需要用到的一些初始化数据其中有个transient 关键字啥意思啊。。就是不允许序列化（不允许序列化我从哪里拿来的元素序列化的啊？？？？还实现了序列化接口搞事情）

private transient Object[] elementData;

//ArrayList中有个方法如下：

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);

        // 疑问你为了节省不序列化为空的位置，这边循环了一次，是不是影响了效率。。还是说读的效率很高这点小小循环的无所谓。。
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

//解释如下：
  //这就跟这个ArrayList的特性有关，我们知道ArrayList的容量，也就是这个数组的容量，一般都是预留一些容量，等到容量不够时再拓展，那么就会出现容量还有冗余的情况，如果这时候进行序列化，整个数组都会被序列化，连后面没有意义空元素的也被序列化。这些是不应该被存储的。所以java的设计者，就为这个类提供了一个writeObject方法，在实现了Serializable接口的类，如果这个类提供了writeObject方法，那么在进行序列化的时候就会通过writeObject方法进行序列化，所以ArrayList的writeObject方法就会显式的为每个实际的数组元素进行序列化，只序列化有用的元素。


private static final Object[] EMPTY_ELEMENTDATA = {};
private static final int DEFAULT_CAPACITY = 10;
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//添加入口
public boolean add(E e) {
        ensureCapacityInternal(size + 1);  //JDK1.7中默认无参构造器size是0，第一次add的时候形参是0+1=1
        elementData[size++] = e;//添加元素，size自增
        return true;
    }
//扩容
 private void ensureCapacityInternal(int minCapacity) {//minCapacity=1
        if (elementData == EMPTY_ELEMENTDATA) {//第一次调用add方法，我们new的时候list的容量是0是个空数组，在这边给他赋值最小容量是10
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }

private void ensureExplicitCapacity(int minCapacity) {//1，至少需要这么大的容量
        modCount++;//这个的作用查了下是ArrayList也采用了快速失败的机制，通过记录modCount参数来实现。在面对并发的修改时，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。有时间再看看

        if (minCapacity - elementData.length > 0)//至少需要的容量比数组的长度来的大才需要扩容
            grow(minCapacity);
    }

 private void grow(int minCapacity) {//真正扩容的代码

        int oldCapacity = elementData.length; //老数组容量
        int newCapacity = oldCapacity + (oldCapacity >> 1);//扩容后新数组的容量 jdk1.7用了效率更高的位运算计算新扩容后的数组的长度
        if (newCapacity - minCapacity < 0)   //假设新数组容量比最小需要的长度小，扩容大小就按照最小的实际需要给
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)//超过Math最大值-8的话，看你最小需要的大小是不是比MAX_ARRAY_SIZE 这个大，大的话就给最大值，否则就是MAX_ARRAY_SIZE 
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);//调用Arrays的静态方法，造一个newCapacity大小的数组然后把以前的copy过去
    }

 private static int hugeCapacity(int minCapacity) {//jdk1.7之前没有Integer.MAX_VALUE这个东西
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

详细解释下这句扩容代码：int newCapacity = oldCapacity + (oldCapacity >> 1);（JDK1.7的版本）
之前的版本有些是这么写的：int newCapacity = (oldCapacity * 3)/2 + 1;

看到扩容的时候把元素组大小先乘以3，再除以2，最后加1。为什么？我们可以想：

1、如果一次性扩容扩得太大，必然造成内存空间的浪费

2、如果一次性扩容扩得不够，那么下一次扩容的操作必然比较快地会到来，这会降低程序运行效率，要知道扩容还是比价耗费性能的一个操作

还没写完。。。。。。