目录：

0-0-1. 前言

0-0-2. 集合框架知识回顾

0-0-3. ArrayList简介

0-0-4. ArrayList核心源码

0-0-5. ArrayList源码剖析

0-0-6. ArrayList经典Demo

前言：

　　这篇文章，其实几天前就已经在图书馆写出来了，不过手一抖几个删除键就都没有了，所以一直拖到了现在。这篇文章在分析ArrayList的时候对ArrayList源码中用到的比较好的语法也会作以陈述。希望通过这篇文章可以让你从本质上认识ArrayList，笔者愚笨，如若遇到错误敬请告知。

集合框架知识回顾：

总体知识脉络

ArrayList简介：

　　ArrayList 的底层是数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。

　　在我们学数据结构的时候就知道了线性表的顺序存储，插入删除元素的时间复杂度为O（n）,求表长以及增加元素，取第 i 元素的时间复杂度为O（1）

　　ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。

　　ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。

　　ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。

　　ArrayList 实现java.io.Serializable接口，这意味着ArrayList**支持序列化，能通过序列化去传输**。

　　和Vector不同，ArrayList中的操作不是线程安全的！所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。

ArrayList核心源码：

  1. package java.util;
  3. import java.util.function.Consumer;
  4. import java.util.function.Predicate;
  5. import java.util.function.UnaryOperator;
  7. public class ArrayList<E> extends AbstractList<E>
  8.         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  9. {
  10.     private static final long serialVersionUID = 8683452581122892189L;
  12.     /**
  13.      * 默认初始容量大小
  14.      */
  15.     private static final int DEFAULT_CAPACITY = 10;
  17.     /**
  18.      * 空数组（用于空实例）。
  19.      */
  20.     private static final Object[] EMPTY_ELEMENTDATA = {};
  22.      //用于默认大小空实例的共享空数组实例。
  23.       //我们把它从EMPTY_ELEMENTDATA数组中区分出来，以知道在添加第一个元素时容量需要增加多少。
  24.     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
  26.     /**
  27.      * 保存ArrayList数据的数组
  28.      */
  29.     transient Object[] elementData; // non-private to simplify nested class access
  31.     /**
  32.      * ArrayList 所包含的元素个数
  33.      */
  34.     private int size;
  36.     /**
  37.      * 带初始容量参数的构造函数。（用户自己指定容量）
  38.      */
  39.     public ArrayList(int initialCapacity) {
  40.         if (initialCapacity > 0) {
  41.             //创建initialCapacity大小的数组
  42.             this.elementData = new Object[initialCapacity];
  43.         } else if (initialCapacity == 0) {
  44.             //创建空数组
  45.             this.elementData = EMPTY_ELEMENTDATA;
  46.         } else {
  47.             throw new IllegalArgumentException("Illegal Capacity: "+
  48.                                                initialCapacity);
  49.         }
  50.     }
  52.     /**
  53.      *默认构造函数，其默认初始容量为10
  54.      */
  55.     public ArrayList() {
  56.         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
  57.     }
  59.     /**
  60.      * 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
  61.      */
  62.     public ArrayList(Collection<? extends E> c) {
  63.         //
  64.         elementData = c.toArray();
  65.         //如果指定集合元素个数不为0
  66.         if ((size = elementData.length) != 0) {
  67.             // c.toArray 可能返回的不是Object类型的数组所以加上下面的语句用于判断，
  68.             //这里用到了反射里面的getClass()方法
  69.             if (elementData.getClass() != Object[].class)
  70.                 elementData = Arrays.copyOf(elementData, size, Object[].class);
  71.         } else {
  72.             // 用空数组代替
  73.             this.elementData = EMPTY_ELEMENTDATA;
  74.         }
  75.     }
  77.     /**
  78.      * 修改这个ArrayList实例的容量是列表的当前大小。 应用程序可以使用此操作来最小化ArrayList实例的存储。
  79.      */
  80.     public void trimToSize() {
  81.         modCount++;
  82.         if (size < elementData.length) {
  83.             elementData = (size == 0)
  84.               ? EMPTY_ELEMENTDATA
  85.               : Arrays.copyOf(elementData, size);
  86.         }
  87.     }
  88. //下面是ArrayList的扩容机制
  89. //ArrayList的扩容机制提高了性能，如果每次只扩充一个，
  90. //那么频繁的插入会导致频繁的拷贝，降低性能，而ArrayList的扩容机制避免了这种情况。
  91.     /**
  92.      * 如有必要，增加此ArrayList实例的容量，以确保它至少能容纳元素的数量
  93.      * @param   minCapacity   所需的最小容量
  94.      */
  95.     public void ensureCapacity(int minCapacity) {
  96.         int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
  97.             // any size if not default element table
  98.             ? 0
  99.             // larger than default for default empty table. It's already
  100.             // supposed to be at default size.
  101.             : DEFAULT_CAPACITY;
  103.         if (minCapacity > minExpand) {
  104.             ensureExplicitCapacity(minCapacity);
  105.         }
  106.     }
  107.    //得到最小扩容量
  108.     private void ensureCapacityInternal(int minCapacity) {
  109.         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
  110.               // 获取默认的容量和传入参数的较大值
  111.             minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
  112.         }
  114.         ensureExplicitCapacity(minCapacity);
  115.     }
  116.   //判断是否需要扩容
  117.     private void ensureExplicitCapacity(int minCapacity) {
  118.         modCount++;
  120.         // overflow-conscious code
  121.         if (minCapacity - elementData.length > 0)
  122.             //调用grow方法进行扩容，调用此方法代表已经开始扩容了
  123.             grow(minCapacity);
  124.     }
  126.     /**
  127.      * 要分配的最大数组大小
  128.      */
  129.     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
  131.     /**
  132.      * ArrayList扩容的核心方法。
  133.      */
  134.     private void grow(int minCapacity) {
  135.         // oldCapacity为旧容量，newCapacity为新容量
  136.         int oldCapacity = elementData.length;
  137.         //将oldCapacity 右移一位，其效果相当于oldCapacity /2，
  138.         //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
  139.         int newCapacity = oldCapacity + (oldCapacity >> 1);
  140.         //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
  141.         if (newCapacity - minCapacity < 0)
  142.             newCapacity = minCapacity;
  143.         //再检查新容量是否超出了ArrayList所定义的最大容量，
  144.         //若超出了，则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE，
  145.         //如果minCapacity大于最大容量，则新容量则为ArrayList定义的最大容量，否则，新容量大小则为 minCapacity。
  146.         if (newCapacity - MAX_ARRAY_SIZE > 0)
  147.             newCapacity = hugeCapacity(minCapacity);
  148.         // minCapacity is usually close to size, so this is a win:
  149.         elementData = Arrays.copyOf(elementData, newCapacity);
  150.     }
  151.     //比较minCapacity和 MAX_ARRAY_SIZE
  152.     private static int hugeCapacity(int minCapacity) {
  153.         if (minCapacity < 0) // overflow
  154.             throw new OutOfMemoryError();
  155.         return (minCapacity > MAX_ARRAY_SIZE) ?
  156.             Integer.MAX_VALUE :
  157.             MAX_ARRAY_SIZE;
  158.     }
  160.     /**
  161.      *返回此列表中的元素数。
  162.      */
  163.     public int size() {
  164.         return size;
  165.     }
  167.     /**
  168.      * 如果此列表不包含元素，则返回 true 。
  169.      */
  170.     public boolean isEmpty() {
  171.         //注意=和==的区别
  172.         return size == 0;
  173.     }
  175.     /**
  176.      * 如果此列表包含指定的元素，则返回true 。
  177.      */
  178.     public boolean contains(Object o) {
  179.         //indexOf()方法：返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为-1
  180.         return indexOf(o) >= 0;
  181.     }
  183.     /**
  184.      *返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为-1
  185.      */
  186.     public int indexOf(Object o) {
  187.         if (o == null) {
  188.             for (int i = 0; i < size; i++)
  189.                 if (elementData[i]==null)
  190.                     return i;
  191.         } else {
  192.             for (int i = 0; i < size; i++)
  193.                 //equals()方法比较
  194.                 if (o.equals(elementData[i]))
  195.                     return i;
  196.         }
  197.         return -1;
  198.     }
  200.     /**
  201.      * 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。.
  202.      */
  203.     public int lastIndexOf(Object o) {
  204.         if (o == null) {
  205.             for (int i = size-1; i >= 0; i--)
  206.                 if (elementData[i]==null)
  207.                     return i;
  208.         } else {
  209.             for (int i = size-1; i >= 0; i--)
  210.                 if (o.equals(elementData[i]))
  211.                     return i;
  212.         }
  213.         return -1;
  214.     }
  216.     /**
  217.      * 返回此ArrayList实例的浅拷贝。 （元素本身不被复制。）
  218.      */
  219.     public Object clone() {
  220.         try {
  221.             ArrayList<?> v = (ArrayList<?>) super.clone();
  222.             //Arrays.copyOf功能是实现数组的复制，返回复制后的数组。参数是被复制的数组和复制的长度
  223.             v.elementData = Arrays.copyOf(elementData, size);
  224.             v.modCount = 0;
  225.             return v;
  226.         } catch (CloneNotSupportedException e) {
  227.             // 这不应该发生，因为我们是可以克隆的
  228.             throw new InternalError(e);
  229.         }
  230.     }
  232.     /**
  233.      *以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
  234.      *返回的数组将是“安全的”，因为该列表不保留对它的引用。 （换句话说，这个方法必须分配一个新的数组）。
  235.      *因此，调用者可以自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。
  236.      */
  237.     public Object[] toArray() {
  238.         return Arrays.copyOf(elementData, size);
  239.     }
  241.     /**
  242.      * 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）;
  243.      *返回的数组的运行时类型是指定数组的运行时类型。 如果列表适合指定的数组，则返回其中。
  244.      *否则，将为指定数组的运行时类型和此列表的大小分配一个新数组。
  245.      *如果列表适用于指定的数组，其余空间（即数组的列表数量多于此元素），则紧跟在集合结束后的数组中的元素设置为null 。
  246.      *（这仅在调用者知道列表不包含任何空元素的情况下才能确定列表的长度。）
  247.      */
  248.     @SuppressWarnings("unchecked")
  249.     public <T> T[] toArray(T[] a) {
  250.         if (a.length < size)
  251.             // 新建一个运行时类型的数组，但是ArrayList数组的内容
  252.             return (T[]) Arrays.copyOf(elementData, size, a.getClass());
  253.             //调用System提供的arraycopy()方法实现数组之间的复制
  254.         System.arraycopy(elementData, 0, a, 0, size);
  255.         if (a.length > size)
  256.             a[size] = null;
  257.         return a;
  258.     }
  260.     // Positional Access Operations
  262.     @SuppressWarnings("unchecked")
  263.     E elementData(int index) {
  264.         return (E) elementData[index];
  265.     }
  267.     /**
  268.      * 返回此列表中指定位置的元素。
  269.      */
  270.     public E get(int index) {
  271.         rangeCheck(index);
  273.         return elementData(index);
  274.     }
  276.     /**
  277.      * 用指定的元素替换此列表中指定位置的元素。
  278.      */
  279.     public E set(int index, E element) {
  280.         //对index进行界限检查
  281.         rangeCheck(index);
  283.         E oldValue = elementData(index);
  284.         elementData[index] = element;
  285.         //返回原来在这个位置的元素
  286.         return oldValue;
  287.     }
  289.     /**
  290.      * 将指定的元素追加到此列表的末尾。
  291.      */
  292.     public boolean add(E e) {
  293.         ensureCapacityInternal(size + 1);  // Increments modCount!!
  294.         //这里看到ArrayList添加元素的实质就相当于为数组赋值
  295.         elementData[size++] = e;
  296.         return true;
  297.     }
  299.     /**
  300.      * 在此列表中的指定位置插入指定的元素。
  301.      *先调用 rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 方法保证capacity足够大；
  302.      *再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。
  303.      */
  304.     public void add(int index, E element) {
  305.         rangeCheckForAdd(index);
  307.         ensureCapacityInternal(size + 1);  // Increments modCount!!
  308.         //arraycopy()这个实现数组之间复制的方法一定要看一下，下面就用到了arraycopy()方法实现数组自己复制自己
  309.         System.arraycopy(elementData, index, elementData, index + 1,
  310.                          size - index);
  311.         elementData[index] = element;
  312.         size++;
  313.     }
  315.     /**
  316.      * 删除该列表中指定位置的元素。 将任何后续元素移动到左侧（从其索引中减去一个元素）。
  317.      */
  318.     public E remove(int index) {
  319.         rangeCheck(index);
  321.         modCount++;
  322.         E oldValue = elementData(index);
  324.         int numMoved = size - index - 1;
  325.         if (numMoved > 0)
  326.             System.arraycopy(elementData, index+1, elementData, index,
  327.                              numMoved);
  328.         elementData[--size] = null; // clear to let GC do its work
  329.       //从列表中删除的元素
  330.         return oldValue;
  331.     }
  333.     /**
  334.      * 从列表中删除指定元素的第一个出现（如果存在）。 如果列表不包含该元素，则它不会更改。
  335.      *返回true，如果此列表包含指定的元素
  336.      */
  337.     public boolean remove(Object o) {
  338.         if (o == null) {
  339.             for (int index = 0; index < size; index++)
  340.                 if (elementData[index] == null) {
  341.                     fastRemove(index);
  342.                     return true;
  343.                 }
  344.         } else {
  345.             for (int index = 0; index < size; index++)
  346.                 if (o.equals(elementData[index])) {
  347.                     fastRemove(index);
  348.                     return true;
  349.                 }
  350.         }
  351.         return false;
  352.     }
  354.     /*
  355.      * Private remove method that skips bounds checking and does not
  356.      * return the value removed.
  357.      */
  358.     private void fastRemove(int index) {
  359.         modCount++;
  360.         int numMoved = size - index - 1;
  361.         if (numMoved > 0)
  362.             System.arraycopy(elementData, index+1, elementData, index,
  363.                              numMoved);
  364.         elementData[--size] = null; // clear to let GC do its work
  365.     }
  367.     /**
  368.      * 从列表中删除所有元素。
  369.      */
  370.     public void clear() {
  371.         modCount++;
  373.         // 把数组中所有的元素的值设为null
  374.         for (int i = 0; i < size; i++)
  375.             elementData[i] = null;
  377.         size = 0;
  378.     }
  380.     /**
  381.      * 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。
  382.      */
  383.     public boolean addAll(Collection<? extends E> c) {
  384.         Object[] a = c.toArray();
  385.         int numNew = a.length;
  386.         ensureCapacityInternal(size + numNew);  // Increments modCount
  387.         System.arraycopy(a, 0, elementData, size, numNew);
  388.         size += numNew;
  389.         return numNew != 0;
  390.     }
  392.     /**
  393.      * 将指定集合中的所有元素插入到此列表中，从指定的位置开始。
  394.      */
  395.     public boolean addAll(int index, Collection<? extends E> c) {
  396.         rangeCheckForAdd(index);
  398.         Object[] a = c.toArray();
  399.         int numNew = a.length;
  400.         ensureCapacityInternal(size + numNew);  // Increments modCount
  402.         int numMoved = size - index;
  403.         if (numMoved > 0)
  404.             System.arraycopy(elementData, index, elementData, index + numNew,
  405.                              numMoved);
  407.         System.arraycopy(a, 0, elementData, index, numNew);
  408.         size += numNew;
  409.         return numNew != 0;
  410.     }
  412.     /**
  413.      * 从此列表中删除所有索引为fromIndex （含）和toIndex之间的元素。
  414.      *将任何后续元素移动到左侧（减少其索引）。
  415.      */
  416.     protected void removeRange(int fromIndex, int toIndex) {
  417.         modCount++;
  418.         int numMoved = size - toIndex;
  419.         System.arraycopy(elementData, toIndex, elementData, fromIndex,
  420.                          numMoved);
  422.         // clear to let GC do its work
  423.         int newSize = size - (toIndex-fromIndex);
  424.         for (int i = newSize; i < size; i++) {
  425.             elementData[i] = null;
  426.         }
  427.         size = newSize;
  428.     }
  430.     /**
  431.      * 检查给定的索引是否在范围内。
  432.      */
  433.     private void rangeCheck(int index) {
  434.         if (index >= size)
  435.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  436.     }
  438.     /**
  439.      * add和addAll使用的rangeCheck的一个版本
  440.      */
  441.     private void rangeCheckForAdd(int index) {
  442.         if (index > size || index < 0)
  443.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  444.     }
  446.     /**
  447.      * 返回IndexOutOfBoundsException细节信息
  448.      */
  449.     private String outOfBoundsMsg(int index) {
  450.         return "Index: "+index+", Size: "+size;
  451.     }
  453.     /**
  454.      * 从此列表中删除指定集合中包含的所有元素。
  455.      */
  456.     public boolean removeAll(Collection<?> c) {
  457.         Objects.requireNonNull(c);
  458.         //如果此列表被修改则返回true
  459.         return batchRemove(c, false);
  460.     }
  462.     /**
  463.      * 仅保留此列表中包含在指定集合中的元素。
  464.      *换句话说，从此列表中删除其中不包含在指定集合中的所有元素。
  465.      */
  466.     public boolean retainAll(Collection<?> c) {
  467.         Objects.requireNonNull(c);
  468.         return batchRemove(c, true);
  469.     }
  471.     /**
  472.      * 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
  473.      *指定的索引表示初始调用将返回的第一个元素为next 。 初始调用previous将返回指定索引减1的元素。
  474.      *返回的列表迭代器是fail-fast 。
  475.      */
  476.     public ListIterator<E> listIterator(int index) {
  477.         if (index < 0 || index > size)
  478.             throw new IndexOutOfBoundsException("Index: "+index);
  479.         return new ListItr(index);
  480.     }
  482.     /**
  483.      *返回列表中的列表迭代器（按适当的顺序）。
  484.      *返回的列表迭代器是fail-fast 。
  485.      */
  486.     public ListIterator<E> listIterator() {
  487.         return new ListItr(0);
  488.     }
  490.     /**
  491.      *以正确的顺序返回该列表中的元素的迭代器。
  492.      *返回的迭代器是fail-fast 。
  493.      */
  494.     public Iterator<E> iterator() {
  495.         return new Itr();
  496.     }

ArrayList源码分析：

System.arraycopy()和Arrays.copyOf()方法

　　通过上面源码我们发现这两个实现数组复制的方法被广泛使用而且很多地方都特别巧妙。比如下面add(int index, E element)方法就很巧妙的用到了arraycopy()方法让数组自己复制自己实现让index开始之后的所有成员后移一个位置:

  1.     /**
  2.      * 在此列表中的指定位置插入指定的元素。
  3.      *先调用 rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 方法保证capacity足够大；
  4.      *再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。
  5.      */
  6.     public void add(int index, E element) {
  7.         rangeCheckForAdd(index);
  9.         ensureCapacityInternal(size + 1);  // Increments modCount!!
  10.         //arraycopy()方法实现数组自己复制自己
  11.         //elementData:源数组;index:源数组中的起始位置;elementData：目标数组；index + 1：目标数组中的起始位置； size - index：要复制的数组元素的数量；
  12.         System.arraycopy(elementData, index, elementData, index + 1, size - index);
  13.         elementData[index] = element;
  14.         size++;
  15.     }

又如toArray()方法中用到了copyOf()方法


  2.     /**
  3.      *以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
  4.      *返回的数组将是“安全的”，因为该列表不保留对它的引用。 （换句话说，这个方法必须分配一个新的数组）。
  5.      *因此，调用者可以自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。
  6.      */
  7.     public Object[] toArray() {
  8.     //elementData：要复制的数组；size：要复制的长度
  9.         return Arrays.copyOf(elementData, size);
  10.     }
两者联系与区别：

联系：

看两者源代码可以发现copyOf()内部调用了System.arraycopy()方法

区别：

1，arraycopy()需要目标数组，将原数组拷贝到你自己定义的数组里，而且可以选择拷贝的起点和长度以及放入新数组中的位置

2，copyOf()是系统自动在内部新建一个数组，并返回该数组。

ArrayList核心扩容技术

  1. //下面是ArrayList的扩容机制
  2. //ArrayList的扩容机制提高了性能，如果每次只扩充一个，
  3. //那么频繁的插入会导致频繁的拷贝，降低性能，而ArrayList的扩容机制避免了这种情况。
  4.     /**
  5.      * 如有必要，增加此ArrayList实例的容量，以确保它至少能容纳元素的数量
  6.      * @param   minCapacity   所需的最小容量
  7.      */
  8.     public void ensureCapacity(int minCapacity) {
  9.         int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
  10.             // any size if not default element table
  11.             ? 0
  12.             // larger than default for default empty table. It's already
  13.             // supposed to be at default size.
  14.             : DEFAULT_CAPACITY;
  16.         if (minCapacity > minExpand) {
  17.             ensureExplicitCapacity(minCapacity);
  18.         }
  19.     }
  20.    //得到最小扩容量
  21.     private void ensureCapacityInternal(int minCapacity) {
  22.         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
  23.               // 获取默认的容量和传入参数的较大值
  24.             minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
  25.         }
  27.         ensureExplicitCapacity(minCapacity);
  28.     }
  29.   //判断是否需要扩容,上面两个方法都要调用
  30.     private void ensureExplicitCapacity(int minCapacity) {
  31.         modCount++;
  33.         // 如果说minCapacity也就是所需的最小容量大于保存ArrayList数据的数组的长度的话，就需要调用grow(minCapacity)方法扩容。
  34.         //这个minCapacity到底为多少呢？举个例子在添加元素(add)方法中这个minCapacity的大小就为现在数组的长度加1
  35.         if (minCapacity - elementData.length > 0)
  36.             //调用grow方法进行扩容，调用此方法代表已经开始扩容了
  37.             grow(minCapacity);
  38.     }
  1.     /**
  2.      * ArrayList扩容的核心方法。
  3.      */
  4.     private void grow(int minCapacity) {
  5.        //elementData为保存ArrayList数据的数组
  6.        ///elementData.length求数组长度elementData.size是求数组中的元素个数
  7.         // oldCapacity为旧容量，newCapacity为新容量
  8.         int oldCapacity = elementData.length;
  9.         //将oldCapacity 右移一位，其效果相当于oldCapacity /2，
  10.         //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
  11.         int newCapacity = oldCapacity + (oldCapacity >> 1);
  12.         //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
  13.         if (newCapacity - minCapacity < 0)
  14.             newCapacity = minCapacity;
  15.         //再检查新容量是否超出了ArrayList所定义的最大容量，
  16.         //若超出了，则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE，
  17.         //如果minCapacity大于最大容量，则新容量则为ArrayList定义的最大容量，否则，新容量大小则为 minCapacity。
  18.         if (newCapacity - MAX_ARRAY_SIZE > 0)
  19.             newCapacity = hugeCapacity(minCapacity);
  20.         // minCapacity is usually close to size, so this is a win:
  21.         elementData = Arrays.copyOf(elementData, newCapacity);
  22.     }

　　扩容机制代码已经做了详细的解释。另外值得注意的是大家很容易忽略的一个运算符：移位运算符

　　简介：移位运算符就是在二进制的基础上对数字进行平移。按照平移的方向和填充数字的规则分为三种:<<(左移)、>>(带符号右移)和>>>(无符号右移)。

　　作用：对于大数据的2进制运算,位移运算符比那些普通运算符的运算要快很多,因为程序仅仅移动一下而已,不去计算,这样提高了效率,节省了资源

　　比如这里：int newCapacity = oldCapacity + (oldCapacity >> 1);

右移一位相当于除2，右移n位相当于除以2的n次方。这里oldCapacity 明显右移了1位所以相当于oldCapacity /2。

另外需要注意的是：

  1. java中的length属性是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了length这个属性.

  2. java中的length()方法是针对字 符串String说的,如果想看这个字符串的长度则用到length()这个方法.

  3. .java中的size()方法是针对泛型集合说的,如果想看这个泛型有多少个元素,就调用此方法来查看!

内部类

  1.     (1)private class Itr implements Iterator<E>
  2.     (2)private class ListItr extends Itr implements ListIterator<E>
  3.     (3)private class SubList extends AbstractList<E> implements RandomAccess
  4.     (4)static final class ArrayListSpliterator<E> implements Spliterator<E>

　　ArrayList有四个内部类，其中的Itr是实现了Iterator接口，同时重写了里面的hasNext()，next()，remove()等方法；其中的ListItr继承Itr，实现了ListIterator接口，同时重写了hasPrevious()，nextIndex()，previousIndex()，previous()，set(E e)，add(E e)等方法，所以这也可以看出了Iterator和ListIterator的区别:**ListIterator在Iterator的基础上增加了添加对象，修改对象，逆向遍历等方法，这些是Iterator不能实现的。具体可以参考http://blog.csdn.net/a597926661/article/details/7679765。其中的**SubList继承AbstractList，实现了RandmAccess接口，类内部实现了对子序列的增删改查等方法，但它同时也充分利用了内部类的优点，就是共享ArrayList的全局变量，例如检查器变量modCount，数组elementData等，所以SubList进行的增删改查操作都是对ArrayList的数组进行的，并没有创建新的数组。(内部类这里参考了这位老兄的博客http://blog.csdn.net/ljcitworld/article/details/52041836)

ArrayList经典Demo：

  1. package list;
  2. import java.util.ArrayList;
  3. import java.util.Iterator;
  5. public class ArrayListDemo {
  7.     public static void main(String[] srgs){
  8.          ArrayList<Integer> arrayList = new ArrayList<Integer>();
  10.          System.out.printf("Before add:arrayList.size() = %d\n",arrayList.size());
  12.          arrayList.add(1);
  13.          arrayList.add(3);
  14.          arrayList.add(5);
  15.          arrayList.add(7);
  16.          arrayList.add(9);
  17.          System.out.printf("After add:arrayList.size() = %d\n",arrayList.size());
  19.          System.out.println("Printing elements of arrayList");
  20.          // 三种遍历方式打印元素
  21.          // 第一种：通过迭代器遍历
  22.          System.out.print("通过迭代器遍历:");
  23.          Iterator<Integer> it = arrayList.iterator();
  24.          while(it.hasNext()){
  25.              System.out.print(it.next() + " ");
  26.          }
  27.          System.out.println();
  29.          // 第二种：通过索引值遍历
  30.          System.out.print("通过索引值遍历:");
  31.          for(int i = 0; i < arrayList.size(); i++){
  32.              System.out.print(arrayList.get(i) + " ");
  33.          }
  34.          System.out.println();
  36.          // 第三种：for循环遍历
  37.          System.out.print("for循环遍历:");
  38.          for(Integer number : arrayList){
  39.              System.out.print(number + " ");
  40.          }
  42.          // toArray用法
  43.          // 第一种方式(最常用)
  44.          Integer[] integer = arrayList.toArray(new Integer[0]);
  46.          // 第二种方式(容易理解)
  47.          Integer[] integer1 = new Integer[arrayList.size()];
  48.          arrayList.toArray(integer1);
  50.          // 抛出异常，java不支持向下转型
  51.          //Integer[] integer2 = new Integer[arrayList.size()];
  52.          //integer2 = arrayList.toArray();
  53.          System.out.println();
  55.          // 在指定位置添加元素
  56.          arrayList.add(2,2);
  57.          // 删除指定位置上的元素
  58.          arrayList.remove(2);
  59.          // 删除指定元素
  60.          arrayList.remove((Object)3);
  61.          // 判断arrayList是否包含5
  62.          System.out.println("ArrayList contains 5 is: " + arrayList.contains(5));
  64.          // 清空ArrayList
  65.          arrayList.clear();
  66.          // 判断ArrayList是否为空
  67.          System.out.println("ArrayList is empty: " + arrayList.isEmpty());
  68.     }
  69. }

欢迎关注我的微信公众号（分享各种Java学习资源，面试题，以及企业级Java实战项目回复关键字免费领取）：

集合框架源码学习之ArrayList的更多相关文章

  1. 集合框架源码学习之HashMap(JDK1.8)

    目录: 0-1. 简介 0-2. 内部结构分析 0-2-1. JDK18之前 0-2-2. JDK18之后 0-3. LinkedList源码分析 0-3-1. 构造方法 0-3-2. put方法 0 ...

  2. 集合框架源码学习之LinkedList

    0-1. 简介 0-2. 内部结构分析 0-3. LinkedList源码分析 0-3-1. 构造方法 0-3-2. 添加add方法 0-3-3. 根据位置取数据的方法 0-3-4. 根据对象得到索引 ...

  3. 【java集合框架源码剖析系列】java源码剖析之ArrayList

    注:博主java集合框架源码剖析系列的源码全部基于JDK1.8.0版本. 本博客将从源码角度带领大家学习关于ArrayList的知识. 一ArrayList类的定义: public class Arr ...

  4. 【java集合框架源码剖析系列】java源码剖析之HashMap

    前言:之所以打算写java集合框架源码剖析系列博客是因为自己反思了一下阿里内推一面的失败(估计没过,因为写此博客已距阿里巴巴一面一个星期),当时面试完之后感觉自己回答的挺好的,而且据面试官最后说的这几 ...

  5. 【java集合框架源码剖析系列】java源码剖析之TreeSet

    本博客将从源码的角度带领大家学习TreeSet相关的知识. 一TreeSet类的定义: public class TreeSet<E> extends AbstractSet<E&g ...

  6. 【java集合框架源码剖析系列】java源码剖析之HashSet

    注:博主java集合框架源码剖析系列的源码全部基于JDK1.8.0版本.本博客将从源码角度带领大家学习关于HashSet的知识. 一HashSet的定义: public class HashSet&l ...

  7. 【java集合框架源码剖析系列】java源码剖析之TreeMap

    注:博主java集合框架源码剖析系列的源码全部基于JDK1.8.0版本.本博客将从源码角度带领大家学习关于TreeMap的知识. 一TreeMap的定义: public class TreeMap&l ...

  8. 【java集合框架源码剖析系列】java源码剖析之LinkedList

    注:博主java集合框架源码剖析系列的源码全部基于JDK1.8.0版本. 在实际项目中LinkedList也是使用频率非常高的一种集合,本博客将从源码角度带领大家学习关于LinkedList的知识. ...

  9. ABP框架源码学习之修改默认数据库表前缀或表名称

    ABP框架源码学习之修改默认数据库表前缀或表名称 1,源码 namespace Abp.Zero.EntityFramework { /// <summary> /// Extension ...

随机推荐

  1. 利用 Pandoc 将 Markdown 生成 Word/PDF 文件

    Pandoc 是一个格式转化工具,可以用于各(luan)种(qi)各(ba)样(zao)的文件转换, 反正我是认不全官网上的那个图(傲娇脸), 之前一直使用它将 Markdown 文件转换成 Html ...

  2. [Leetcode] 2.Add Two Numbers（List To Long，模拟）

    本题题意是指将两个数倒序存储在链表中,再将两数之和同样存储在链表中输出. 我最开始的思路是将每一位相加,再考虑是否进位,但这时就需要考虑一些情况,比较麻烦. 于是我决定采取另一种在网上新学到的方法:这 ...

  3. BZOJ3997 TJOI2015组合数学（动态规划）

    copy: Dilworth定理:DAG的最小链覆盖=最大点独立集 最小链覆盖指选出最少的链(可以重复)使得每个点都在至少一条链中 最大点独立集指最大的集合使集合中任意两点不可达 此题中独立的定义即是 ...

  4. vue-cli项目打包出现空白页和路径错误问题

    vue-cli项目打包: 1. 命令行输入:npm  run  build 打包出来后项目中就会多了一个文件夹dist,这就是我们打包过后的项目. 第一个问题,文件引用路径.我们直接运行打包后的文件夹 ...

  5. 51nod 1304 字符串的相似度（exkmp）

    拓展kmp裸题 自己跟自己匹配即可 模板测试=v= #include <iostream> #include <cstring> using namespace std; ; ...

  6. 用select （多路复用）模拟一个 socket server

    需求:用select (多路复用)模拟一个 socket server.可以接收多并发. 1. 一开始是检测自己,如果我有活动了,就说明有客户端要连我了. #用select去模拟socket,实现单线 ...

  7. [BZOJ2961] 共点圆 [cdq分治+凸包]

    题面 BZOJ传送门 思路 首先考虑一个点$(x_0,y_0)$什么时候在一个圆$(x_1,y_1,\sqrt{x_1^2+y_1^2})$内 显然有:$x_1^2+y_1^2\geq (x_0-x_ ...

  8. spring+springMVC+mybatis较全

    1.基本概念   1.1.Spring   Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On- ...

  9. BZOJ1014：[JSOI2008]火星人prefix——题解

    http://www.lydsy.com/JudgeOnline/problem.php?id=1014 Description 火星人最近研究了一种操作:求一个字串两个后缀的公共前缀.比方说,有这样 ...

  10. AOJ.859 地毯填补问题 (递归与分治)

    AOJ.859 地毯填补问题 (递归与分治) 题意分析 学习分治思想,第一次接触, 代码总览 #include <iostream> #include <cstdio> #in ...