ArrayList源码学习

Posted 2020-10-27 moseast

一、 类与成员变量：

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

ArrayList继承自AbstractList抽象类，实现了List<E>、RandomAccess、Cloneable、Serializable接口。

其中：

 

实现RandomAccess接口的List可以通过简单的for循环来访问数据比使用iterator访问来的高效快速。

实现Cloneable接口的类的对象允许被克隆。同时该类需要重写Object类的clone方法。

实现Serializable接口，即采用了Java默认的序列化机制。

 

private static final long serialVersionUID = 8683452581122892189L;

serialVersionUID 是源类的哈希值。有了serialVersionUID之后，那么如果序列化的类已经保存了在本地中，中途你更改了类后，serialVersionUID变了，那么反序列化的时候就不会变成原始的类了，还会抛异常，主要就是用于版本控制。

*序列化的作用是能转化成Byte流，然后又能反序列化成原始的类。能在网络进行传输，也可以保存在磁盘中。

 

private transient Object[] elementData;

private int size;

transient关键字的作用：在采用Java默认的序列化机制的时候，被该关键字修饰的属性不会被序列化。但是Object[] elementData属性是ArrayList的底层数据结构，在网络传输中一定需要将其序列化，之后使用的时候还需要反序列化，那不采用Java默认的序列化机制，那采用什么呢？直接翻到源码的最下边有两个方法，发现ArrayList自己实现了序列化和反序列化的方法writeObject()、readObject()。

writeObject()、readObject()的源码：

/**
     * Save the state of the <tt>ArrayList</tt> instance to a stream (that
     * is, serialize it).
     *
     * @serialData The length of the array backing the <tt>ArrayList</tt>
     *             instance is emitted (int), followed by all of its elements
     *             (each an <tt>Object</tt>) in the proper order.
     */
    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 array length
        s.writeInt(elementData.length);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++)
            s.writeObject(elementData[i]);

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

    }

    /**
     * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,
     * deserialize it).
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
    // Read in size, and any hidden stuff
    s.defaultReadObject();

        // Read in array length and allocate array
        int arrayLength = s.readInt();
        Object[] a = elementData = new Object[arrayLength];

    // Read in all elements in the proper order.
    for (int i=0; i<size; i++)
            a[i] = s.readObject();
    }

 

二、构造：

public ArrayList(int initialCapacity) {
　
　　//父类的构造器，调用子类构造时必须先调用父类构造，通常为隐式调用。若父类没有无 参构造，则必须显示调用。
    super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
    this.elementData = new Object[initialCapacity];
}

 public ArrayList() {
    this(10);
}

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

 

当我们执行 new ArrayList<String>()时，会调用无参构造，实际是调用ArrayList(int initialCapacity)创建了一个容量为10的对象。

当我们执行 new ArrayList<String>(2)时，会调用ArrayList(int initialCapacity)，创建了一个容量为2的对象。

**在实际使用中，如果可以估算出所需的大小，建议调用ArrayList(int initialCapacity)构造，如估计需要放置18个元素到容器，就可以new ArrayList<String>(20)，这样会减少数组扩容时引起的效率下降。

当我们执行 new ArrayList<String>(Collection c)时，实际是将其他Collection容器转为ArrayList对象。

 

三、操作ArrayList

1、添加

 public boolean add(E e) {
　　ensureCapacity(size + 1);  // Increments modCount!!
　　elementData[size++] = e;
　　return true;
 }

 public void ensureCapacity(int minCapacity) {
　　modCount++;
　　int oldCapacity = elementData.length;
　　if (minCapacity > oldCapacity) {
        Object oldData[] = elementData;
        int newCapacity = (oldCapacity * 3)/2 + 1;
        if (newCapacity < minCapacity)
        　　newCapacity = minCapacity;
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
}