Java ArrayList小记

1.基本用法

　　ArrayList是一个泛型容器，新建ArrayList需要实例化泛型参数，比如:

ArrayList<String> StrList = new ArrayList<>();
ArrayList<Integer> intList = new ArrayList<>();

　　ArrayList的主要方法有：

// 添加元素到末尾
public boolean add(E e)
// 判断是否为空
public boolean isEmpty()
// 获取大小
public int size()
// 获取指定位置（索引）的元素
public E get(int index)
// 查找指定元素，若找到，返回索引位置，否则返回-1
public int indexOf(Object o)
// 从后往前找
public int lastIndexOf(Object o)
// 判断是否包含指定元素，根据equals方法的返回值
public boolean contains(Object o)
// 删除指定位置的元素，返回值为被删除的元素对象
public E remove(int index)
// 删除指定元素，只删除第一个相同的元素，若o为null,则删除值为null的元素
public boolean remove(Object o)
// 清空元素
public void clear()
// 在指定位置插入元素，index为0表示插入最前面，index为ArrayList的长度表示插到最后面
public void add(int index, E element)
// 修改指定位置的元素内容
public E set(int index, E element) 

　　简单示例：

ArrayList<String> strList = new ArrayList<>();
strList.add("我爱");
strList.add("编程");
for (int i = 0; i < strList.size(); i++) {
    System.out.println(strList.get(i));
}

2.基本原理

　　ArrayList是基于数组实现的，内部有一个数组elementData，还有一个整数size记录实际的元素个数（基于Java 8），如下所示：

transient Object[] elementData;
private int size;

　　先来看下add和remove方法的实现。add方法的主要代码为：

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

　　首先调用ensureCapacityInternal确保数组容量是够的，ensureCapacityInternal的代码为：

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

　　首先calculateCapacity方法判断数组是否为空，若为空，则首次至少分配的大小为DEFAULT_CAPACITY（默认为10）。然后调用ensureExplicitCapacity方法，modCount表示内部的修改次数，如果需要的长度大于当前数组的长度，则调用grow方法，其主要代码为：

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        // 右移一位相当于除以2，所以，newCapacity相当于oldCapacity的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 如果扩展1.5倍还是小于minCapacity，就扩展为minCapacity
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        // 确保newCapacity不超过VM允许的最大值
        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);
    }

　　再来看看remove方法的代码：

    public E remove(int index) {
        // 检查给定索引是否在范围内，若不在抛出运行时异常。
        rangeCheck(index);
        modCount++;
        E oldValue = elementData(index);
        // 计算要移动的元素个数，index后面的都要移动
        int numMoved = size - index - 1;
        if (numMoved > 0)
            // 通过数组copy来移动元素
            System.arraycopy(elementData, index+1, elementData, index, numMoved);
        // 数组最后一位，置为null,完成删除
        elementData[--size] = null; // clear to let GC do its work
        return oldValue;
    }

　　使用modCount记录修改次数。使用数组拷贝来移动元素，最后将“移动”到末尾的元素设置为null，完成删除。

3.迭代

　　来看下迭代操作的例子，循环打印ArrayList中的每个元素，ArrayList支持foreach语法：

        ArrayList<Integer> list = new ArrayList<>();
        list.addAll(Arrays.asList(9, 5, 6, 7));
        for (Integer i : list) {
            System.out.print(i + " ");
        }
        System.out.println(" ");
        // 或者
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }

　　使用foreach看上去更为简洁，具体选择使用哪种要根据具体情况，如若需要使用索引就不方便使用foreach了。那么这种foreach语法背后是怎么实现的呢？其实，编译器会将它转换为如下代码：

        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next() + " ");
        }

　　ArrayList实现了Iterable接口，Iterable表示可迭代，Java 8中迭代器接口：

public interface Iterable<T> {

    Iterator<T> iterator();

    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

　　一个抽象方法和两个默认方法，默认方法是java 8新增的，具体使用方式参考API文档 。来看下iterator方法，它返回一个实现了Iterator接口的对象，Java 8中Iterator接口的定义为：

public interface Iterator<E> {
    boolean hasNext();

    E next();

    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

　　hasNext()判断是否还有下一个元素，next()返回下一个元素，remove()删除最后返回的元素，只读访问的基本模式类似于：

        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next() + " ");
        }

　　只要对象实现了Iterable接口，就可以使用foreach语法，编译器会转换为调用Iterable和Iterator接口的方法。下面来区分下这两个接口：

　　1. Iterable表示对象可以被迭代，它有一个iterator方法，返回Iterator对象，实际通过Iterator接口的方法进行遍历；

　　2. 如果对象实现了Iterable接口，就可以使用foreach语法；

　　3. 类可以不实现Iterable，也可以创建Iterator对象。

　　除了iterator()，ArrayList还提供了两个返回Iterator接口的方法：

public ListIterator<E> listIterator()
public ListIterator<E> listIterator(int index)

　　ListIterator扩展了Iterator接口，增加了一些方法，向前遍历，添加元素，修改元素，返回索引位置等，添加的方法有：

public interface ListIterator<E> extends Iterator<E> {
    boolean hasPrevious();
    E previous();
    int nextIndex();
    int previousIndex();
    void set(E e);
    void add(E e);
}

　　listIterator()方法返回的迭代器从0开始，而listIterator(int index)方法返回的迭代器从指定位置的index开始。比如反向遍历：

    public static void reverseTraverse(List<Integer> list) {
        ListIterator<Integer> it = list.listIterator(list.size());
        while (it.hasPrevious()) {
            System.out.println(it.previous() + " ");
        }
    }

　　关于迭代器，有一种常见的错误使用，就是在迭代的中间调用容器的删除方法。比如如下代码：

    public static void wrongUsage(List<Integer> list) {
        for (Integer x : list) {
            if (x < 20) {
                list.remove(x);
            }
        }

        /**
         * java.util.ConcurrentModificationException
         */
    }

　　运行时会抛出上面注释中异常，发生了并发修改异常。由于迭代器内部会维护一些索引位置相关的数据，要求在迭代过程中，容器不能发生结构性变化，否则这些索引位置就失效了。结构性变化指的是添加、插入和删除元素，只是修改元素内容不算结构性变化。那么如何避免异常呢？可以使用迭代器的remove方法：

    public static void remove(ArrayList<Integer> list) {
        Iterator<Integer> it = list.iterator();
        while (it.hasNext()) {
            if (it.next() < 20) {
                it.remove();
            }
        }
    }

　　为什么使用迭代器自己的remove方法不抛出异常呢？来看下ArrayList中iterator方法的实现：

    public Iterator<E> iterator() {
        return new Itr();
    }

　　新建了一个Itr对象，Itr是一个成员内部类，实现了Iterabtor接口，声明为：

    private class Itr implements Iterator<E> {
        // 下一个要返回的元素位置
        int cursor = 0;
        // 最后一个返回的索引位置，如果没有，为-1
        int lastRet = -1;
        // 期望的修改次数
        int expectedModCount = modCount;
        public boolean hasNext() {
            return cursor != size();
        }

        public E next() {
            checkForComodification();
            try {
                int i = cursor;
                E next = get(i);
                lastRet = i;
                cursor = i + 1;
                return next;
            } catch (IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                // 迭代器的删除调用了外部类的remove,同时又更新了cursor、lastRet和expectedModCountde值，所以它可以正确的删除
                AbstractList.this.remove(lastRet);
                if (lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

　　modCount是外部类中当前修改次数，成员内类可以直接访问外部类的实例变量。每次发生结构变化的时候modCount都会增加1，而每次迭代器操作的时候都会检查expectedModCount是否与modCount相等，这样就能检测出结构变化了。在使用迭代器的remove时有一点需要注意，在调用remove之前必须先调用next，否则会抛出java.lang.IllegalStateException 异常，因为直接调用lastRet参数默认为-1，还没被赋值。

　　迭代器表示的是一种关注点分离的思想，将数据的实际组织方式与数据的迭代遍历相分离，是一种常见的设计模式。定义如下：

　　它提供一种方法访问一个容器对象中各个元素， 而又不需暴露该对象的内部细节。--迭代器模式

4. ArrayList实现的接口

　　Java的各种容器类有一些共性的操作，这些共性以接口的方式体现，例如Iterable，此外AarrayList还实现了三个主要的接口：Collection、List和RandomAccess接口。

1. Collection

　　Conllection表示一个数据的集合，位置间没有位置或顺序的概念，Java 8中定义的接口为：

public interface Collection<E> extends Iterable<E> {
    // 集合大小
    int size();
    // 判断集合是否为空
    boolean isEmpty();
    // 判断集合是否包含指定元素
    boolean contains(Object o);
    // 迭代器
    Iterator<E> iterator();
    // 转换为数组
    Object[] toArray();
    // 转换为数组并制定返回类型
    <T> T[] toArray(T[] a);
    // 添加元素
    boolean add(E e);
    // 删除指定元素
    boolean remove(Object o);
    // 判断给定集合是否包含在当前集合
    boolean containsAll(Collection<?> c);
    // 将给定集合添加到当前集合中
    boolean addAll(Collection<? extends E> c);
    // 将给定集合的内容从当前集合中移除
    boolean removeAll(Collection<?> c);
    default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final Iterator<E> each = iterator();
        while (each.hasNext()) {
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }
    // 判断当前集合中是否包含给定的集合
    boolean retainAll(Collection<?> c);
    // 清空集合
    void clear();
    boolean equals(Object o);
    int hashCode();
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}

　　默认方法略过，可查看API学习。抽象类AbstractCollection对这些方法都提供了默认实现，ArrayList继承了AbstactList，而AbstractList又继承了AbstractCollection，ArrayList对其中的一些方法进行了重写，以提供更高的效率。

2. List

　　List表示有顺序并且可重复的数据集合，它扩展了Collection接口（java 8）：

public interface List<E> extends Collection<E> {

    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    <T> T[] toArray(T[] a);
    boolean add(E e);
    boolean remove(Object o);
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean addAll(int index, Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
    boolean retainAll(Collection<?> c);
    default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }
    @SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }
    void clear();
    boolean equals(Object o);
    int hashCode();
    E get(int index);
    E set(int index, E element);
    void add(int index, E element);
    E remove(int index);
    int indexOf(Object o);
    int lastIndexOf(Object o);
    ListIterator<E> listIterator();
    ListIterator<E> listIterator(int index);
    List<E> subList(int fromIndex, int toIndex);
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }
}

　　默认方法先混个脸熟，其它扩展的几个方法都和位置有关，可根据API文档学习。

3. RandomAccess

　　RandomAccess接口定义如下：

public interface RandomAccess {
}

　　这是一个标记接口，用于声明类的一种属性。实现该接口的类表示可以随机访问，就是具备类似数组那样的特性，数据在内存中是连续存放的，根据索引值就可以直接定位到具体的元素，访问效率很高。根据这个声明，在一些算法代码中可以选择效率更高的实现。比如Collections类中的binarySearch方法：

    public static <T>
    int binarySearch(List<? extends Comparable<? super T>> list, T key) {
        // 这里就根据是否实现了RandomAccess接口选择效率更高的算法
        if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
            return Collections.indexedBinarySearch(list, key);
        else
            return Collections.iteratorBinarySearch(list, key);
    }

5. ArrayList特点总结

　　ArrayList内部是采用动态数组实现的：

　　1. 可以随机访问（实现了RandomAccess接口），按照索引位置进行访问效率很高效率为O（1），简单来说就是一步到位。

　　2. 在数组未排序的情况下，查找元素效率比较低，具体是O（N），N为数组内容长度，性能与数组长度成正比。

　　3. 添加元素的效率还可以，但是被重新分配和复制数组的开销被均摊了，添加N个元素的效率为O(N)。

　　4. 插入和删除元素的效率比较低，因为需要复制、移动元素，具体为O(N)。

---------- I love three things in this world. Sun, moon and you. Sun for morning, moon for night , and you forever .