集合框架专题3—ArrayList

ArrayList

         前言：  本文所采用的jdk版本为：jdk1.8.0_111。

        一、首先我们来看一下ArrayList的成员变量

    private static final int DEFAULT_CAPACITY = 10;

    private static final Object[] EMPTY_ELEMENTDATA = {};

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    transient Object[] elementData; // non-private to simplify nested class access

    private int size;

        上面有几个需要解释一下:

        1. DEFAULT_CAPACITY  这里是指ArrayList的默认容量，即在创建ArrayList时，如未刻意指定其容量，则ArrayList默认创建一个容量为10的数组用于存放元素。

        2.elementData  这个变量是用于存放ArrayList实例中的所有元素的地方，这里可以看出ArrayList实际上是基于数组的形式实现的。

二、构造器

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

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

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

        ArrayList中有3个构造器，一个是默认无参构造器，一个是指定初始化数组容量的构造器，一个是创建ArrayList时默认传入一批Collection集合元素的构造器。

三、常用方法

3.1 trimToSize()

    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

        该方法削减ArrayList的内存容量至刚好存放当前元素为止。实际应用场景中在，当内存吃紧的时候，可以对不再更改的ArrayList实例使用该方法来释放些内存。

3.2 indexOf(Object o)

    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

        该方法在上一篇的AbstractList中已经介绍了一次，AbstractList是采用ListIterator迭代的形式进行元素的查找，在这里是采用最基础的数组循环来做的，实际上我们在看了ArrayList的这些方法，我们可以看出ArrayList内部的功能都没有通过迭代器来实现，而是对数组方面的操作，说明ArrayLIst实际上是对数组的一个高级的封装。

3.3 lastIndexOf(Object o)

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

        与上一篇的思路一样，采用倒序的形式查找元素，再返回元素与参数相同时的下标，总体来看就是查找参数在ArrayList中最后一次出现的位置。

3.4 get(int index)

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

        return elementData(index);
    }

        根据下标得到对应的元素。

3.5 set(int index,E element)

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

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

        将元素按照给定的下标位置，set进去，然后返回被替换掉的老的元素。

3.6 add(E e)

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 按需扩容量，这个方法感兴趣的可以点进去看一下源码，可以看出他扩容的一个过程，并不是简单的+1这么简单
        elementData[size++] = e;
        return true;
    }

        意思是在原有的列表的末尾加上传入的元素。

3.7 add(int index, E element)

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

        按照给定的位置，将元素插入进去。对于学过数据结构的人应该都很清楚，对于数组执行插入操作效率是非常低的一件事情，这里也可以看出来，首先数组先将指定位置的后续元素都向后移一位，然后再将新元素赋值进去。

        所以在实际运用场景中，如果碰到有插入操作的时候，尽量避免使用ArrayList数组列表，它适合元素不改变元素位置以及只在队尾执行插入删除操作的场景下应用。

3.8 remove(int index)

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

        按照给定位置，将元素删除。与上面方法的思路相似，将给定位置之后的元素向前覆盖一位，再删除末尾元素，即达到效果，这里的效率很低，原因上面已经说过。所以有这种场景的时候，应避免使用ArrayList数组列表。

3.9 addAll(Collection<? extends E> c)

    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

        先将参数中的c转化为数组，原数组列表进行扩容，再将c转化的数组放到原数组列表的末尾。

3.10 addAll(int index, Collection<? extends E> c)

    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount

        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

        该方法与上一方法大致类似，只是可以按照给定的位置进行插入，效率问题也是比较低。

        如果有应用场景对本身列表的结构上没有什么更改，仅仅只在队尾进行新增删除操作的话，建议使用ArrayList数组列表，因为其对于列表中数据查询方面的效率非常高的。但是假如有应用场景是需要本身对列表进行中间的插入删除或者排序等操作，则不建议使用ArrayList数组列表，因为它的执行效率很低。综合而言，优劣都有，需要来看实际使用场景。