Arraylist的个人理解

Arraylist的个人理解

所谓Arraylist,我的理解就是它是一个动态的可灵活变更大小的数组，或者是叫动态数组，它允许任何元素的插入，包括null，它的特点是：有序的(按照添加的顺序),不唯一：同一个元素可以装多次。

它的初始化容量为10，如果增加元素大于10，那么它就会进行扩容操作

private static final Object[] EMPTY_ELEMENTDATA = {};
transient Object[] elementData;//源码中有多处表示它是一个数组

transient Object[] elementData; // non-private to simplify nested class access
//存放元素的数组

它是Array的复杂版本。List接口的大小可变数组的实现，位于API文档的Java.util.ArrayList<E>。实现了所有可选列表操作，并允许包括null在内的所有元素。除了实现List接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。

public class ArrayList<E> extends AbstractList<E>//继承AbstractList

每个ArrayList实例都有一个容量。是指用来存储列表元素的数组的大小。

 private static final int DEFAULT_CAPACITY = 10;//原始大小为10

还有数组当前的元素数量

public int size() {
        return size;
    }
//返回此列表中的元素数

此外ArrayList还有许多方法：比如

 public E get(int index) {
        rangeCheck(index);
​
        return elementData(index);
    }
//get方法：将此列表中指定位置的元素替换为指定元素，返回先前在指定位置的元素

  public E set(int index, E element) {
        rangeCheck(index);
​
        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }//set方法：将指定元素替换到此指定位置（index)，返回值由 Collection.add 指定(index位置原来的元素)

 public boolean add(E e) {//增加一个元素
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;//在数组尾部添加元素，并将size+1
        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);
        elementData[index] = element;
        size++;
    }//将指定的元素插入此列表中的指定位置

 public void clear() {移除此列表中的所有元素
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

   public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }//如果此列表中包含指定的元素，则返回true

  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);
        }
    }//如有必要，增加此ArrayList实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数

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

        return elementData(index);
    }//返回此列表中指定位置上的元素

public boolean isEmpty() {
        return size == 0;
    }//如果此列表中没有元素，则返回true

    public int lastIndexOf(Object o) {
        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;
    }//返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回-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;
    }//移除此列表中指定位置上的元素

  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;
    }//移除列表中首次出现的指定元素，前提是存在

    protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);

        // clear to let GC do its work
        int newSize = size - (toIndex-fromIndex);
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        size = newSize;
    }//移除列表中索引在fromIndex(包括)和toIndex(不包括)之间的所有元素

   public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }//按适当顺序(从第一个到最后一个元素)返回包含此列表中所有元素的数组

    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;
    }//按适当顺序(从第一个到最后一个元素)返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型

   public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }//将此ArrayList实例的容量调整为列表的当前大小

以上的代码均来自ArrayList源码，方法解释来源于百度百科，