ArrayList

【Rookie初学Java】ArrayList是什么

数组：

狭义上的数组指的就是一堆存储数的连续内存空间

广义上来说，只要是一片连续空间存储的“数据“都可以称作数组，这也是ArrayList存在的原因吧，可以存放任何数据类型。

1成员变量

private static final long serialVersionUID = 8683452581122892189L;
    /**
     * 默认初始容量：10
     */
    private static final int DEFAULT_CAPACITY = 10;
    /**
     * 空数组，使用 new ArrayList<>() 创建 ArrayList 时，使用的数组
     */
    private static final Object[] EMPTY_ELEMENTDATA = {}; 
    /**
     * 空数组，在添加第一个数组的时候变成默认容量的数组
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    /**
     * 这个是我们真实存放数据的数组，transient修饰的非私有属性
     */
    transient Object[] elementData;
    /**
     * 数组的大小，指的是存放对象的数量
     */
    private int size;

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

数组最大size为Integer.MAX_VALUE - 8。

需要8bytes的存储大小表示数组的长度等元数据。所以数组的大小定义为Integer.MAX_VALUE - 8。

2方法理解

2.1构造方法

2.1.1有参构造

Constructs an empty list with the specified initial capacity./构造一个具有指定初始容量的空列表。
Params:
initialCapacity – the initial capacity of the list /initialCapacity—列表的初始容量
Throws:
IllegalArgumentException – if the specified initial capacity is negative/IllegalArgumentException -如果指定的初始容量为负值

通过给定参数构造该参数大小的数组，这个时候我们应该思考了，给定的数可能有几种可能，我们通过一系列业务操作对不同的情况进行讨论，选择抛异常的方式处理不合法数据，也是为了更加直观的告诉用户，哪里出现错误了。

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

2.1.2无参构造

Constructs an empty list with an initial capacity of ten.构造一个初始容量为10的空列表。

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

Constructs a list containing the elements of the specified collection, in the order they are returned by the collection’s iterator./构造一个包含指定集合元素的列表，按照集合的迭代器返回元素的顺序排列。
Params:
c – the collection whose elements are to be placed into this list
Throws:
NullPointerException – if the specified collection is null

public ArrayList(Collection<? extends E> c) {
    Object[] a = c.toArray();//调用toArray方法将c转为数组，因为这里使用的是集合的对象，多态
    if ((size = a.length) != 0) {
        if (c.getClass() == ArrayList.class) {
            elementData = a;
        } else {
            elementData = Arrays.copyOf(a, size, Object[].class);
        }
    } else {
        // replace with empty array.
        elementData = EMPTY_ELEMENTDATA;
    }
}

我们可以通过这个构造将任何Collection的对象或者其子类的对象作为元素来构造一个数组

getClass()返回运行时的类；如果c是ArrayList的对象就直接将引用赋给elementData（真实存储数据的数组）

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType)

Array.copyOf方法： Array.copyOf() 用于复制指定的数组内容以达到扩容的目的，将旧数组按指定大小拷贝到新数组

执行这个方法的目的在于将目标集合转变为我们ArrayList对象

2.2trimToSize()

将ArrayList实例的容量修剪为

列表的当前大小。 应用程序可以使用此操作最小化

一个ArrayList实例的存储。

public void trimToSize() {
    modCount++;//对数组操作的次数++
    if (size < elementData.length) {
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size);//三目运算
    }
}

如果数组不为空就将数组copy到一个新的数组，大小为size

2.3 ensureCapacity(int )

增加这个ArrayList实例的容量，以确保它至少可以容纳最小容量参数指定的元素数量

一句话：防止越界，用来检查数组

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

如果需要扩容就调用ensureExplicitCapacity。

2.4 calculateCapacity(Object[] elementData, int minCapacity)

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);//为0则返回10
        }
        return minCapacity;//不为0则返回minCapacity
    }

从源码看来，该方法是为了确定一次add，原数组需要最小的长度

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)//最后一次判断最小容量是否合理
        grow(minCapacity);
}

每一次add都会传入size+1给minCapacity，说明它进行了扩容。

最后调用grow()

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);//每次扩容1.5倍目的或许是防止每次添加都扩容浪费时间
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;//如果还是小了就直接吧minCapacity给newCapacity
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);//如果超出数组最大值就执行hugeCapacity，进一步扩大数组的大小
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

从grow方法中我们可以看到每一次扩容都会扩大为原来的1.5倍，或许是为了防止每一次添加（add）都扩容浪费时间

再次调用Arrays.copyOf将就数组拷贝到新数组。

public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

2.5其他方法

2.5.1contains

如果列表中包含指定的元素，则返回true。 更正式地说，当且仅当列表中包含至少一个元素e满足(o==null ? e = = null: o.equals (e))。

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

2.5.2indexOf

返回列表中指定元素第一次出现的索引，如果列表中不包含该元素，则返回-1。 更准确地来说，返回最低的索引

public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)//如果为null也需要进行判断
                return i;
    } else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))//o需要重写了equals方法，对每一个属性都进行判断
                return i;
    }
    return -1;//不存在就返回-1
}

public int lastIndexOf(Object o) {//和indexOf功能相似，只不过是反向判断
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = size-1; i >= 0; i--)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

2.5.3toArray

看到这个方法的时候不知道你是不是也和我一样有点疑惑呢？

为什么数组要有toArray方法？

个人感觉是因为实现了List接口的原因吧，不得不重写。

返回一个数组，该数组包含列表中的所有元素

需要拿一个引用来接住它

public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

注意的是返回数组类型为Object类型。

抛出:

ArrayStoreException—如果指定数组的运行时类型不是列表中每个元素的运行时类型的父类型

public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

指定转成的数组类型，这个类型必须是原本类型的父类。

2.5.4isEmpty()

public boolean isEmpty() {
    return size == 0;
}

2.5.5clone()

返回此ArrayList实例的浅拷贝。 (元素本身不被复制。)

public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;//这两行做的的是初始化的操作
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}

注意这里是浅拷贝！！

2.5.6对于数组元素操作的方法

• elementData()

用这个方法来获得指定下标的元素

E elementData(int index) {
    return (E) elementData[index];
}

• rangeCheck()

越界就抛异常

private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

• get()

public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

get方法和elementData方法不同的地方在于多了一步检索

• set()

public E set(int index, E element) {
    rangeCheck(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

set方法给定的下标需要在数组范围内，因为我们是修改对应下标的元素，和添加不一样，值得一提的是，这个方法返回值为oldValue，因为我们不需要返回自己添加的值，也不需要返回是否添加成功，只要不抛异常就代表成功，那么我们就要让他返回一些有用的值，比如之前的数据。

• add()

在此列表的指定位置插入指定元素。 将当前位于该位置的元素(如果有)和任何后续元素向右移动(在其索引上加1)。

    public boolean add(E e) {
        ensureCapacityInternal(size + 1); 
        elementData[size++] = e;
        return true;
    }

   public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!   先对数组扩容
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);//从index下标开始，将后面的元素全部拷贝到index+1之后
        elementData[index] = element;//将index下标的值赋为element
        size++;
    }

值得一提的是，如果每次扩容之后（每次初步扩大为1.5倍）还是不够储存元素，那么就会将数组扩大到指定大小，而不是1.5倍了。

arraycopy是native修饰的方法，想继续了解的话可以去下载openjdk。

public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

几个参数分别对应 原数组，拷贝起始位置，目的数组，拷贝目标位置，拷贝长度。

• remove()

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; //最后一个位置为null，并且size减少1

        return oldValue;
    }

和add相类似，只是arraycopy从index+1开始向前面一个位置拷贝。

除此以外还有一个移除元素的remove，这里不进行说明了，采用的算法是遍历，对于null也需要判断。

• fastRemove()

和remove不同的是，少了一步对于是否越界的判断（rangeCheck）和返回值，因为在if语句中，能够执行fastRemove就说明一定含有该元素，可以放心删~