ArrayList解析

##List接口

package java.util;

import java.util.function.Predicate;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public interface List<E> extends Collection<E> {
    //获取元素个数，如果超过Integer.MAX_VALUE返回Integer.MAX_VALUE
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    //Returns an iterator over the elements in this list in proper sequence.
    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);
    }
}

##ArrayList
ArrayList是线性结构，是由数组实现的，相当于动态数组。
ArrayList在保留数组可以快速查找的优势的基础上，弥补了数据在创建后，要往数据添加元素的弊端。

Array的扩容，如果初始化是6，下一次扩容的长度是6+6>>2 = 9 以此类推。如果初始化没有大小，第一次默认分配的是10，10+10>>2 = 15以此类推。

###ArrayList线程不安全
这样也就出现了第一个导致线程不安全的隐患，在多个线程进行add操作时可能会导致elementData数组越界。具体逻辑如下：

列表大小为9，即size=9
线程A开始进入add方法，这时它获取到size的值为9，调用ensureCapacityInternal方法进行容量判断。
线程B此时也进入add方法，它获取到size的值也为9，也开始调用ensureCapacityInternal方法。
线程A发现需求大小为10，而elementData的大小就为10，可以容纳。于是它不再扩容，返回。
线程B也发现需求大小为10，也可以容纳，返回。
线程A开始进行设置值操作， elementData[size++] = e 操作。此时size变为10。
线程B也开始进行设置值操作，它尝试设置elementData[10] = e，而elementData没有进行过扩容，它的下标最大为9。于是此时会报出一个数组越界的异常ArrayIndexOutOfBoundsException.
另外第二步 elementData[size++] = e 设置值的操作同样会导致线程不安全。从这儿可以看出，这步操作也不是一个原子操作，它由如下两步操作构成：

elementData[size] = e;
size = size + 1;
在单线程执行这两条代码时没有任何问题，但是当多线程环境下执行时，可能就会发生一个线程的值覆盖另一个线程添加的值，具体逻辑如下：

列表大小为0，即size=0
线程A开始添加一个元素，值为A。此时它执行第一条操作，将A放在了elementData下标为0的位置上。
接着线程B刚好也要开始添加一个值为B的元素，且走到了第一步操作。此时线程B获取到size的值依然为0，于是它将B也放在了elementData下标为0的位置上。
线程A开始将size的值增加为1
线程B开始将size的值增加为2
这样线程AB执行完毕后，理想中情况为size为2，elementData下标0的位置为A，下标1的位置为B。而实际情况变成了size为2，elementData下标为0的位置变成了B，下标1的位置上什么都没有。并且后续除非使用set方法修改此位置的值，否则将一直为null，因为size为2，添加元素时会从下标为2的位置上开始。

###ArrayList优缺点
优点：

1. 可以通过下标快速的查找数据中的元素。
2. 相比较数组来说，可以自动扩容。

缺点：

1. 线程不安全
2. 如果要在插入一个元素，需要在内存中空出一个元素的空间，然后将要增加的元素放在其中。
3. 删除一个元素，同样需要移动后面的元素使其连续。

代码举例：

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class OssTest {
    public static void main(String[] args) throws IOException, InterruptedException {
        List<String> list = new ArrayList<>(10);
        list.add("1111");
        list.add("2222");
        list.add("3333");
        list.add("4444");
        list.set(2, "12345");
        list.add(1, "2233232");

        List<String> list_addAll= new ArrayList<>(10);
        list_addAll.add("1");
        list_addAll.addAll(0, list);

        System.out.println(list_addAll.get(5));
    }
}