ArrayList源码解析

概述

继承和实现关系

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

ArrayList实现了RandomAccess接口，支持快速随机访问，实现了Serializable接口，
因此它支持序列化，能够实现序列化和反序列化，实现了Cloneable接口，能被克隆。

属性

private static final long serialVersionUID = 8683452581122892189L;

    
	//默认容器大小为10
    private static final int DEFAULT_CAPACITY = 10;

    //空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};

  	
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

 	//存放数据的数组
	//transient 表示其不可被序列化
    transient Object[] elementData; // non-private to simplify nested class access

    //记录数组大小
    private int size;

构造器

//确定容器大小,如果设置的大小小于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
 public ArrayList() {
     this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
 }

 //将实现Collection接口的容器类转化成Arraylist
 public ArrayList(Collection<? extends E> c) {
     elementData = c.toArray();
     if ((size = elementData.length) != 0) {
         // c.toArray might (incorrectly) not return Object[] (see 6260652)
         if (elementData.getClass() != Object[].class)
             elementData = Arrays.copyOf(elementData, size, Object[].class);
     } else {
         // replace with empty array.
         this.elementData = EMPTY_ELEMENTDATA;
     }
 }

常用方法

//将数组大小调整到已经存放数据的大小,因为数组大小是按1.5倍扩展的,所以需要这个方法  
public void trimToSize() {
       modCount++;
       if (size < elementData.length) {
           elementData = (size == 0)
             ? EMPTY_ELEMENTDATA
             : Arrays.copyOf(elementData, size);
       }
   }

//自定义容器大小
  public void ensureCapacity(int minCapacity) {
       int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
           // any size if not default element table
           ? 0
           // larger than default for default empty table. It's already
           // supposed to be at default size.
           : DEFAULT_CAPACITY;

       if (minCapacity > minExpand) {
           ensureExplicitCapacity(minCapacity);
       }
   }

private void ensureExplicitCapacity(int minCapacity) {
    //每次容器进行修改就会+1
       modCount++;

       // 如果设置的大小>实际数组大小则扩大数组容量
       if (minCapacity - elementData.length > 0)
           grow(minCapacity);
   }

  private void grow(int minCapacity) {
     	//拿到数组的大小
       int oldCapacity = elementData.length;
      //先扩大1.5倍
       int newCapacity = oldCapacity + (oldCapacity >> 1);
      //如果扩大后还是小于要设置的容器大小，则扩大到设置的容器大小
       if (newCapacity - minCapacity < 0)
           newCapacity = minCapacity;
      //如果已经大到容器的现在就直接赋值Integer.MAX_VALUE
       if (newCapacity - MAX_ARRAY_SIZE > 0)
           newCapacity = hugeCapacity(minCapacity);
      	//复制数组
       elementData = Arrays.copyOf(elementData, newCapacity);
   }

 public boolean add(E e) {
     //每次添加都要检查容器大小,确定是否要扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
 private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

 private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

11

序列化

//输出序列化
private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
    
        int expectedModCount = modCount;
   
        
        s.writeInt(size);

        //把元素写进去
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }
		//这里考虑到线程问题,如果以输出序列化的时候,对Arraylist进行修改操作就会抛异常
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

    //输入序列化
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in capacity
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            int capacity = calculateCapacity(elementData, size);
            SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
            ensureCapacityInternal(size);

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

标题ArrayList中的迭代器

public ListIterator<E> listIterator(int index) {
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: "+index);
        return new ListItr(index);
    }
   
    public ListIterator<E> listIterator() {
        return new ListItr(0);
    }
    public Iterator<E> iterator() {
        return new Itr();
    }

```private class Itr implements Iterator<E> {
        int cursor;       // 指向下一个元素下标
        int lastRet = -1; // 指向上一个元素下标
    	//和序列化一样,保证遍历时,数组没有被修改过,否则会抛异常
        int expectedModCount = modCount;

        Itr() {}

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            //进行是否修改检查
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }
		//使用迭代器的时候,不能对数组进行修改,但可以对迭代器进行修改,来实现对数组的修改
        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                //实现
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
		//通过lamaba表达式进行操作
        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

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