【集合】ArrayList 源码分析

概述（JDK1.8.0_162）

ArrayList基于数组实现，是一个动态数组，其容量能自动增长，类似于C语言中的动态申请内存，动态增长内存。

每个ArrayList实例都有一个容量，该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向ArrayList中不断添加元素，其容量也自动增长。自动增长会带来数据向新数组的重新拷贝，因此，如果可预知数据量的多少，可在构造ArrayList时指定其容量。在添加大量元素前，应用程序也可以使用ensureCapacity操作来增加ArrayList实例的容量，这可以减少递增式再分配的数量。注意，此实现不是同步的。如果多个线程同时访问一个ArrayList实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。

继承关系

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

实现了RandomAccess接口，支持快速随机访问，实际上就是通过下标序号进行快速访问
实现了Cloneable接口,能被克隆
实现了Serializable接口,支持序列化，能够通过序列化传输

主要成员变量

/**
 * 默认初始化容量
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * 用于空实例的共享空数组实例
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * 用于默认大小的空实例的共享空数组实例
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * 存储ArrayList元素的数组缓冲区
 */
transient Object[] elementData; // non-private to simplify nested class access

/**
 * ArrayList包含的元素数量
 *
 * @serial
 */
private int size;

transient

Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。即：被标记为transient的属性在对象被序列化时不会被保存。

构造函数

/**
 * 初始化时指定容量大小
 */
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);
   }
}

/**
 * 无参构造函数，默认容量为10
 */
public ArrayL ist() {
   this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
 * 初始化一个包含指定Collection的ArrayList
 */
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;
   }
}

元素存储

/**
 * 用指定的元素替代此列表中指定位置上的元素，并返回以前位于该位置上的元素
 */
public E set(int index, E element) {
    rangeCheck(index);

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

/**
 * 将指定的元素添加到此列表的尾部
 */
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

/**
 * 将指定的元素插入此列表中的指定位置,如果当前位置有元素，则向右移动当前位于该位置的元素以及所有后续元素（将其索引加1）
 */
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++;
}
/**
 * 按照指定collection的迭代器所返回的元素顺序，将该collection中的所有元素添加到此列表的尾部
 */
 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;
 }

 /**
  * 从指定的位置开始，将指定collection中的所有元素插入到此列表中
  */
 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;
 }

元素读取

/**
 * 返回列表中指定位置上的元素
 */
public E get(int index) {
    rangeCheck(index);

    return elementData(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;
}

/**
 * 移除此列表中首次出现的指定元素
 */
public boolean remove(Object o) {
   // ArrayList允许存放null值
    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;
}

private void fastRemove(int index) {
    modCount++;
    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
}

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

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

    size = 0;
}

数组扩容

/**
 * 扩容此ArrayList实例的容量，确保至少包含minCapacity指定的元素数
 */
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);
   }
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
   if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
       return Math.max(DEFAULT_CAPACITY, minCapacity);
   }
   return minCapacity;
}

private void ensureCapacityInternal(int minCapacity) {
   ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

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

   // overflow-conscious code
   if (minCapacity - elementData.length > 0)
       grow(minCapacity);
}

/**
 * 要分配的最大数组大小，超过此大小可能会导致OutOfMemoryError：请求的数组大小超过VM限制
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

private void grow(int minCapacity) {
   // overflow-conscious code
   int oldCapacity = elementData.length;
   int newCapacity = oldCapacity + (oldCapacity >> 1);
   if (newCapacity - minCapacity < 0)
       newCapacity = minCapacity;
   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);
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

从上述代码中可以看出，数组进行扩容时，会将老数组中的元素重新拷贝一份到新的数组中，每次数组容量的增长大约是其原容量的1.5倍。这种操作的代价是很高的，因此在实际使用时，我们应该尽量避免数组容量的扩张。当我们可预知要保存的元素的多少时，要在构造ArrayList实例时，就指定其容量，以避免数组扩容的发生。或者根据实际需求，通过调用ensureCapacity方法来手动增加ArrayList实例的容量。

Object oldData[] = elementData;//为什么要用到oldData[]

乍一看来后面并没有用到关于oldData，这句话显得多此一举！但是这是一个牵涉到内存管理的类，所以要了解内部的问题。而且为什么这一句还在if的内部，这跟elementData = Arrays.copyOf(elementData, newCapacity); 这句是有关系的，下面这句Arrays.copyOf的实现时新创建了newCapacity大小的内存，然后把老的elementData放入。好像也没有用到oldData，有什么问题呢。问题就在于旧的内存的引用是elementData， elementData指向了新的内存块，如果有一个局部变量oldData变量引用旧的内存块的话，在copy的过程中就会比较安全，因为这样证明这块老的内存依然有引用，分配内存的时候就不会被侵占掉，然后copy完成后这个局部变量的生命期也过去了，然后释放才是安全的。不然在copy的的时候万一新的内存或其他线程的分配内存侵占了这块老的内存，而copy还没有结束，这将是个严重的事情。

对象数组

/**
 * 返回这个集合的对象数组
 */
public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

/**
 * 返回这个集合的对象数组。
 * 如果传入数组的长度小于size，返回一个新的数组，大小为size，类型与传入数组相同。
 * 如果传入数组的长度等于size，则将elementData复制到传入数组并返回传入的数组。
 * 如果传入数组的长度大于size，除了复制elementData外，还将返回数组的第size个元素置为null。
 */
@SuppressWarnings("unchecked")
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;
}

Fail-Fast机制

ArrayList也采用了快速失败的机制，通过记录modCount参数来实现。在面对并发修改的时候，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。

【集合】ArrayList 源码分析

概述（JDK1.8.0_162）

继承关系

主要成员变量

transient

构造函数

元素存储

元素读取

元素删除

数组扩容

对象数组

Fail-Fast机制

python gdal 安装使用（Windows， python 3.6.8）

【算法一】直接插入

【一】Redis簡單介紹

【算法二】希爾排序

【算法三】簡單選擇

【算法四】堆排序

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結