ArrayList 源码阅读记录

目录

简介

源码分析

简介

• 数组型链表，底层数据结构是数组
• RandomAccess 接口的实现类，表明这是随机访问类型，在有index的情况下，访问的复杂度为O(1)，插入和删除复杂度比较高O(n)
• 不是线程安全的，效率肯定比线程安全的高，单线程情况下使用
• 源码分析没有特别说明，都是基于JDK1.8的

源码分析

1、一些重要的常量和变量

//默认的初始化容量为10 
private static final int DEFAULT_CAPACITY = 10;
 
//空的数组对象 ，用于空实例的共享空数组实例
private static final Object[] EMPTY_ELEMENTDATA = {};
 
//和上面差不多，只是如果使用默认的构造方法，那么久使用这个数组对象
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
 
//不参加序列化的数组对象，数组缓冲区，长度就是ArrayList的容量
transient Object[] elementData; // non-private to simplify nested class access
 
//modCount 用来记录 ArrayList 结构发生变化的次数。
//结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化
protected transient int modCount = 0;

2、一些重要的方法源码

2.1、初始化的三个方法

    这里需要注意的是，如果预先知道数据的容量大小，那么就填写该容量大小，不然会使用默认的容量，当超过默认容量的时候，会触发扩容机制， 频繁的扩容会浪费资源。

    /**
     *用户自定义初始化容量的初始化方法
     */
	public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } 
    	//如果容量为0 ，使用默认的初始化容量 ，也就是 10
    	else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } 
    	//容量 < 0 ，抛出异常
    	else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
 
    /**
     * 默认初始化容量，10
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
 
    /**
     *复制另外的一个集合
     */
    public ArrayList(Collection 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;  
        }
    }

2.2、add()的方法

    添加元素的时候先ensureCapacityInternal（）方法来确保容量大小是否足够，如果新增的长度大于原有的，则发生扩容机制（grow()方法)，扩容到原来的1.5倍

  //添加单个元素
	public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
 
	private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
 
        ensureExplicitCapacity(minCapacity);
    }
 
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
 
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
 
    /**
     * 可分配的最大数组大小，这里还是预留了8个长度大小
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
 
    /**
     * 数组扩容
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //扩容为原来的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果新容量还是比当前容量小，那么新容量 = 当前容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //如果新容量比可分配的最大数组大小还大，那么调用hugeCapacity()方法
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 进行数组复制
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
 
 
	  private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
          //如果当前容量大于可分配的最大数组大小，那么设置为Integer.MAX_VALUE，否则设定为MAX_ARRAY_SIZE;
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

2.3、序列化

    我当时很好奇，为什么ArrayList还单独写了序列化和反序列化的方法，既然这么写，肯定有些原因的。如果从性能上思考，ArrayList的容量是动态增加的，声明的时候容量过大，那么剩下的就初始化为null，如果全部序列化的话，难免会浪费空间，同时也增加了点性能消耗。所以这里他序列化，只序列化到size这个地方。

   /**
    * 序列化
    */
	private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // 判断前后元素数量是否超出
        int expectedModCount = modCount;
        s.defaultWriteObject();
 
        // 确定序列化大小
        s.writeInt(size);
 
        // 写入数据
        for (int i=0; i
            s.writeObject(elementData[i]);
        }
 
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }
 
    /**
     * 反序列化
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;
 
        //获取序列化的大小
        s.defaultReadObject();
 
        // Read in capacity
        s.readInt(); // ignored
 
        if (size > 0) {
            // 根据大小而不是容量来分配数组
            ensureCapacityInternal(size);
 
            Object[] a = elementData;
            // 数据读出
            for (int i=0; i
                a[i] = s.readObject();
            }
        }
    }

2.4、remove()方法

调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，该操作的时间复杂度为 O(N)

/**
    *删除列表中指定位置的元素。
	*将任何后续元素向左移动(从它们的元素中减去1)
    */
	public E remove(int index) {
        //确认边界
        rangeCheck(index);
		
        modCount++;
        E oldValue = elementData(index);
 
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
 
        return oldValue;
    }
 
	/**
     * 删除列表中指定元素，遍历，然后获取index，调用fastRemove(),最后还是根据index来进行删除
     */
	  public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }
 
    /*
     * 私有删除方法，该方法跳过界限检查而不跳过
	 * 返回删除的值
     */
    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }