JDK9.0 ArrayList源码阅读记录

可被序列化

implements　　java.io.Serializable
private static final long serialVersionUID = 8683452581122892189L;

ArrayList实现了Serializable接口，并指定了serialVersionUID．说明其可以被序列化．

构造函数

ArrayList有三种构造函数

 public ArrayList(int initialCapacity)｛
  if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        }
 ｝

第一种．指定ArrayList初始大小，从构造函数可以看出ArrayList是一个数组．会根据你指定的容量大小创建一个数组．

private static final int DEFAULT_CAPACITY = 10;
 public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

第二种．不指定容量大小，使用默认容量大小10．

 public ArrayList(Collection<? extends E> c)

第三种，由其他集合构成．

ArrayList有两个大小，size和elementData.length．size是实际使用的大小．比如你创建了一个初始化容量为1000的ArrayList．但是你只是添加了50个数据，那这个size就为５０.有可能剩下的空间你并没有再使用，可以用如下函数将其占用的空间减少到size.以便节省物理空间．

 public void trimToSize() 

查找元素的索引

从代码可以看出，indexOf查找的是第一个与查找元素相同的索引．也可以使用lastIndexOf查找最后一个匹配的索引．lastIndexOf是逆序查找．

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

添加元素

从代码可以看出，添加元素时并没有进行并发处理，因此ArrayList是线程不安全的类．有可能添加时出现并发错误，导致添加的元素被覆盖掉．remove也是如此．

public void add(int index, E element) {
  rangeCheckForAdd(index);
     modCount++;
     final int s;
     Object[] elementData;
     if ((s = size) == (elementData = this.elementData).length)
       elementData = grow();
    System.arraycopy(elementData, index,
                     elementData, index + 1,
                     s - index);
    elementData[index] = element;
    size = s + 1;
}

迭代器

ＡrrayList有两个迭代器Iterator和ListIterator，使用其来对元素进行遍历
两个的实现类都是实现了Iterator接口．
只不过ListIterator比ＡrrayList多了三个方法

 public E previous()　逆序遍历
　public void set(E e)　设置元素值
 public void add(E e) 　添加元素值

扩容处理

先来看一下添加元素处理，执行添加元素方法public boolean add(E e) 时，实际上调用的是以下方法：

 private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)
        elementData = grow();
    elementData[s] = e;
    size = s + 1;
}

其会先判断当前的容量是否已经使用完，如果使用完则调用方法grow()进行扩容．
再来看grow()方法

private Object[] grow() {
       return grow(size + 1);
 }
 private Object[] grow(int minCapacity) {
        return elementData = Arrays.copyOf(elementData,
                                           newCapacity(minCapacity));
}
//扩容处理
private int newCapacity(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity <= 0) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return minCapacity;
}
return (newCapacity - MAX_ARRAY_SIZE <= 0)
    ? newCapacity
    : hugeCapacity(minCapacity);
}
private static int hugeCapacity(int minCapacity) {
   if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE)
        ? Integer.MAX_VALUE
        : MAX_ARRAY_SIZE;
}

扩容流程：
1. 添加元素，容量不够进行扩容；调用grow()
2. grow()中再调用grow(size + 1)；
3. grow(int minCapacity)中再调用newCapacity(int minCapacity)进行扩容处理；
4. 在原来容量的基础上，增加１／２的容量，并返回最新的容量
5. 使用新的容量进行扩容
6. 最大的容量不超过Integer的最大值
7. 如果minCapacity小，则会抛出OutOfMemoryError异常．

总结

　　如上所描述，ＡrrayList的本质上是一个数组，是一个动态数组，创建时可以指定初始容量大小，当添加元素超过当前的容量大小时会进行扩容处理．
　　需要注意的地方是，ＡrrayList对元素的变更（添加和删除）并没有进行防并发处理，因此具有线程不安全性，使用时需要注意．

相关文章

JDK9.0 ArrayList源码阅读记录
JDK9.0 LinkedList源码阅读记录
ArrayList和LinkedList性能比较
JDK9.0 Vector源码阅读记录
JDK9.0 Hashtable源码阅读记录
Java9.0 HashMap源码阅读记录
JDK9.0 HashSet源码阅读记录