ArrayList源码解析

JAVA基础系列

第一章 ArrayList源码解析

---

---

一、基础概念

简介：ArrayList是Java集合框架中的一个重要的类，从名字上就知道他的底层数据结构是数组，它继承于AbstractList，实现了List接口，是一个长度可变的集合，提供了增删改查的功能，依赖其扩容机制它能够实现集合的动态扩容。
主要特点：查询快，增删慢，线程不安全，效率高。

二、成员变量

    /**
     * 默认初始容量
     */
    private static final int DEFAULT_CAPACITY = 10;
    /**
     * 用于空实例的共享空数组实例
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};
    /**
     * 用于默认大小的空实例的共享空数组实例。（主要在实例化中和EMPTY_ELEMENTDATA有区别）
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    /**
     * 存放数据的数组
     */
    transient Object[] elementData; 
    /**
     * 具体长度
     */
    private int size;

三、构造函数

初始化容量大小为initialCapacity(如果initialCapacity为0，则用EMPTY_ELEMENTDATA做初始化)

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

无参构造器创建一个初始化容量为10的空列表（用DEFAULTCAPACITY_EMPTY_ELEMENTDATA来初始化）

   public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

创建一个包含指定集合所有元素的列表，按照集合的迭代器返回元素的顺序排序

     public ArrayList(Collection<? extends E> c) {
     	//将集合转为数组
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // 
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

四、重要方法

提示：主要是add(E e)系列的方法：

add方法，数据新增

      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 static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

确保显式容量(主要判断是否需要扩容)

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

方法中有一个modCount属性，这个是继承自AbstractList中的字段，表示数组修改的次数，数组每修改一次，就要增加modCount。

扩容方法(如果用无参构造器，新增第一个则扩容为10，如果不是的话就扩容成原来的1.5倍)

    private void grow(int minCapacity) {
        // 
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

主要是add -> ensureCapacityInternal -> calculateCapacity -> ensureExplicitCapacity -> grow这一套流程，根据代码一点点分析就可以找自己想要的结果

总结

好记性不如烂笔头，次次看次次忘，索性写成博客记下来，防止以后再忘！