arraylist底层原理略解（很粗浅易懂）

单列集合图

 

1. ArrayList是一个动态数组，实现了List <E>，RandomAccess，Cloneable，java.io.Serializable，并允许包括null在内的所有元素。

1.1，实现了RandomAccess的接口标识着其支持随机快速访问，实际上，我们查看了RandomAccess源码可以看到，其实里面什么都没有定义。因为ArrayList的底层是数组，那么随机快速访问是理所当然的，访问速度快。

1.2，因为实现了Cloneable的接口，标识着可以它可以被复制。注意，ArrayList的里面的克隆（）复制其实是浅复制

 

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * 默认长度是10
     */
    private static final int DEFAULT_CAPACITY = 10;

public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        // any size if not default element table
        ? 0
        // 默认长度是10

     : DEFAULT_CAPACITY;

if（minCapacity> minExpand）{ensureExplicitCapacity（minCapacity）; }}
 

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

 

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // 需要保持的数据大于现有的容量时,开始扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

 

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    //扩展为原来的1.5倍,    oldCapacity>>1表示往右移一个单位,就是除以2的1次方
    int newCapacity = oldCapacity + (oldCapacity >> 1);
        

 // 如果扩为1.5倍还不满足需求，直接扩为你需要的大小
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    //将原来的长度,拷贝变成扩展后的大小
    elementData = Arrays.copyOf(elementData, newCapacity);
}

 

2.底层使用数组实现，默认初始容量为10.当超出后，会自动扩容为原来的1.5倍，即自动扩容机制。

   数组的扩容是新建一个大容量（原始数组大小+扩充容量）的数组，然后将原始数组数据拷贝到新数组，然后将新数组作为扩容之后的数组。数组扩容的操作代价很高，我们应该尽量减少这种操作。

3.该集合是可变长度数组，数组扩容时，会将老数组中的元素重新拷贝贝一份到新的数组中，每次数组容量增长大约是其容量的1.5倍，如果扩容一半不够，就将目标大小作为扩容后的容量。这种操作的代价很高。采用的是Arrays.copyOf浅复制，

    3.1这里简单说一下什么是浅复制

    浅复制：只复制一个对象，但新对象和老对象同是一个地址值，

    深复制：复制一个对象，新老对象的地址值也变了。

    详情请看（要了解什么是浅复制）：点击打开链接 https://blog.csdn.net/qq_38859786/article/details/80318977

4.采用了Fail-Fast机制，面对并发的修改时，迭代器很快就会完全失败，报异常concurrentModificationException（并发修改一次），而不是冒着在将来某个不确定时间发生任意不确定行为的风险

 

5.删除方法会让下标到数组末尾的元素向前移动一个单位，并把最后一位的值置空，方便GC

 

6.数组扩容代价是很高的，因此在实际使用时，我们应该尽量避免数组容量的扩张。当我们可预知要保存的元素的多少时，要在构造ArrayList实例时，就指定其容量，以避免数组扩容的发生。或者根据实际需求，通过调用的ensureCapacity方法来手动增加的ArrayList实例的容量。

 

7. ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用Collections.synchronizedList（List l）函数返回一个线程安全的ArrayList类，也可以使用并发并发包下的CopyOnWriteArrayList类。

eventbus的订阅方法订阅（）里面，就采用了线程较为安全的的CopyOnWriteArrayList集合

 

 

private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    Class<?> eventType = subscriberMethod.eventType;
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
    CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
    if (subscriptions == null) {
        subscriptions = new CopyOnWriteArrayList<>();
        subscriptionsByEventType.put(eventType, subscriptions);
    } else {
        if (subscriptions.contains(newSubscription)) {
            throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                    + eventType);
        }
    }

 

 

   8，添加（E e）方法作用：添加指定元素到末尾

    如果要增加的数据量很大，应该使用的ensureCapacity（）方法，该方法的作用是预先设置的ArrayList的大小，这样可以大大提高初始化速度。

 

 

Object obj = new Object();
ArrayList list0 = new ArrayList();
long startTime0 = System.currentTimeMillis();
for(int i=0;i<=N;i++){
    list0.add(obj);
}
long endTime0 = System.currentTimeMillis();
Log.e("date", "111没有调用ensureCapacity()方法所用时间：" + (endTime0 - startTime0) + "ms");

ArrayList list1 = new ArrayList();
long startTime1 = System.currentTimeMillis();

list1.ensureCapacity(N);//预先设置list的大小
for(int i=0;i<=N;i++){
    list1.add(obj);
}
long endTime1 = System.currentTimeMillis();
Log.e("date", "222调用ensureCapacity()方法所用时间：" + (endTime1 - startTime1) + "ms");

        9,如果是添加到数组的指定位置,那么可能会挪动大量的数组元素,并且可能会触发扩容机制;如果是添加到末尾的话,那么只可能触发扩容机制.

       10,如果是删除数组指定位置的元素,那么可能会挪动大量的数组元素;如果是删除末尾元素的话,那么代价是最小的. ArrayList里面的删除元素,其实是将该元素置为null.

        11,Collection是最顶层的集合,Collection.toArray()在Collection各个子类的源码中使用频繁

        12，Arrays.copyOf（U [] original，int newLength，Class <？extends T []> newType），就是根据类的类型来决定是new还是反射去构造一个泛型数组，同时利用native functions，批量赋值元素至新数组中。

 

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    //根据class的类型来决定是new还是反射去构造一个泛型数组
            T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    //利用native函数,批量赋值元素至新数组中
    System.arraycopy(original, 0, copy, 0,
            Math.min(original.length, newLength));
    return copy;
}

 

      13，System.arraycopy（）复制数组，也是一个高频使用的函数。