ArrayList源码分析

1 //这里就说明了默认会给10的大小，所以说一开始arrayList的容量是10.
2 　    //ArrayList中储存数据的其实就是一个数组，这个数组就是elementData，在123行定义的 private transient Object[] elementData;
3 　　 public ArrayList() {　　
4             super();        //调用父类中的无参构造方法，父类中的是个空的构造方法
5             this.elementData = EMPTY_ELEMENTDATA;    //EMPTY_ELEMENTDATA：是个空的Object[]， 将elementData初始化，elementData也是个Object[]类型。空的Object[]会给默认大小10。
6         }

1   public ArrayList(int initialCapacity) {
2         super(); //父类中空的构造方法
3         if (initialCapacity < 0)    //判断如果自定义大小的容量小于0，则报非法数据异常
4             throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
5             this.elementData = new Object[initialCapacity]; //将自定义的容量大小当成初始化elementData的大小
6     }

1  //我还有一个Collection<Student>、由于这个Student继承了Person，那么根据这个构造方法，我就可以把这个Collection<Student>转换为ArrayList<Sudent>这就是这个构造方法的作用 
2      public ArrayList(Collection<? extends E> c) {
3         elementData = c.toArray();    //转换为数组
4         size = elementData.length;   //数组中的数据个数
5         if (elementData.getClass() != Object[].class) //每个集合的toarray()的实现方法不一样，所以需要判断一下，如果不是Object[].class类型，那么就需要使用ArrayList中的方法去改造一下。
6             elementData = Arrays.copyOf(elementData, size, Object[].class);
7     }

1 public boolean add(E e) {    
2     //确定内部容量是否够了，size是数组中数据的个数，因为要添加一个元素，所以size+1，先判断size+1的这个数数组能否放得下，就在这个方法中去判断是否数组.length是否够用了。
3         ensureCapacityInternal(size + 1);  
4         //在数据中正确的位置上放上元素e，并且size++
5         elementData[size++] = e;
6         return true;
7     }

1 private void ensureCapacityInternal(int minCapacity) {
2         if (elementData == EMPTY_ELEMENTDATA) { //判断初始化的elementData是不是空的数组，也就是没有长度。因为如果是空的话，minCapacity=size+1；其实就是等于1，空的数组没有长度就存放不了，所以就将minCapacity变成10，也就是默认大小，但是在这里，还没有真正的初始化这个elementData的大小。
3             minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
4         }
5         //确认实际的容量，上面只是将minCapacity=10，这个方法就是真正的判断elementData是否够用
6         ensureExplicitCapacity(minCapacity);
7     }

1 private void ensureExplicitCapacity(int minCapacity) {
2         modCount++;
3 //minCapacity如果大于了实际elementData的长度，那么就说明elementData数组的长度不够用，不够用那么就要增加elementData的length。
4 /*第一种情况：由于elementData初始化时是空的数组，那么第一次add的时候，minCapacity=size+1；也就minCapacity=1，在上一个方法(确定内部容量ensureCapacityInternal)就会判断出是空的数组，就会将minCapacity=10，到这一步为止，还没有改变elementData的大小，
5 　第二种情况：elementData不是空的数组了，那么在add的时候，minCapacity=size+1；也就是minCapacity代表着elementData中增加之后的实际数据个数，拿着它判断elementData的length是否够用，如果length不够用，那么肯定要扩大容量，不然增加的这个元素就会溢出。
6 */
7         if (minCapacity - elementData.length > 0)
8             grow(minCapacity); //arrayList能自动扩展大小的关键方法就在这里了
9     }

 1 private void grow(int minCapacity) {
 2         int oldCapacity = elementData.length;  //将扩充前的elementData大小给oldCapacity
 3         int newCapacity = oldCapacity + (oldCapacity >> 1);    //newCapacity就是1.5倍的oldCapacity
 4         if (newCapacity - minCapacity < 0)//这句话就是适应于elementData为空数组的时候，length=0，那么oldCapacity=0，newCapacity=0，所以这个判断成立，在这里就是真正的初始化elementData的大小了，就是为10。
 5             newCapacity = minCapacity;
 6         if (newCapacity - MAX_ARRAY_SIZE > 0)//如果newCapacity超过了最大的容量限制，就调用hugeCapacity，也就是将能给的最大值给newCapacity
 7             newCapacity = hugeCapacity(minCapacity);
 8         //新的容量大小已经确定好了，就copy数组，改变容量大小。
 9         elementData = Arrays.copyOf(elementData, newCapacity);
10     }

1 //这个就是上面用到的方法，就是用来赋最大值。
2     private static int hugeCapacity(int minCapacity) {
3         if (minCapacity < 0) 
4             throw new OutOfMemoryError();
5 //如果minCapacity都大于MAX_ARRAY_SIZE，那么就Integer.MAX_VALUE返回，反之将MAX_ARRAY_SIZE返回。因为maxCapacity是三倍的minCapacity，可能扩充的太大了，就用minCapacity来判断了。
6 //Integer.MAX_VALUE:2147483647   MAX_ARRAY_SIZE：2147483639  也就是说最大也就能给到第一个数值。还是超过了这个限制，就要溢出了。相当于arraylist给了两层防护。
7         return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE : MAX_ARRAY_SIZE;
8     }

 1 public void add(int index, E element) {
 2         rangeCheckForAdd(index);//检查index也就是插入的位置是否合理。
 3 //跟上面的分析一样，具体看上面
 4         ensureCapacityInternal(size + 1); 
 5 //这个方法就是用来在插入元素之后，要将index之后的元素都往后移一位，
 6         System.arraycopy(elementData, index, elementData, index + 1,  size - index);  //　System.arraycopy(...)：就是将elementData在插入位置后的所有元素往后面移一位
 7 //在目标位置上存放元素
 8         elementData[index] = element;
 9         size++;    //size增加1
10     }

1   private void rangeCheckForAdd(int index) {
2         if (index > size || index < 0)   //插入的位置肯定不能大于size 和小于0
3 　　　　　//如果是，就报这个越界异常
4             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
5     }

 1 public E remove(int index) {
 2         rangeCheck(index);//检查index的合理性
 3         modCount++;//这个作用很多，比如用来检测快速失败的一种标志。
 4         E oldValue = elementData(index);//通过索引直接找到该元素
 5         int numMoved = size - index - 1;//计算要移动的位数。
 6         if (numMoved > 0)
 7 //这个方法也已经解释过了，就是用来移动元素的。
 8             System.arraycopy(elementData, index+1, elementData, index, numMoved);
 9 //将--size上的位置赋值为null，让gc(垃圾回收机制)更快的回收它。
10             elementData[--size] = null; 
11 //返回删除的元素。
12 return oldValue;
13     }

 1 //就是通过元素来删除该元素，就依次遍历，如果有这个元素，就将该元素的索引传给fastRemobe(index)，使用这个方法来删除该元素，fastRemove(index)方法的内部跟remove(index)的实现几乎一样，这里最主要是知道arrayList可以存储null值。
 2      public boolean remove(Object o) {
 3         if (o == null) {
 4             for (int index = 0; index < size; index++)
 5                 if (elementData[index] == null) {
 6                     fastRemove(index);
 7                     return true;
 8                 }
 9         } else {
10             for (int index = 0; index < size; index++)
11                 if (o.equals(elementData[index])) {
12                     fastRemove(index);
13                     return true;
14                 }
15         }
16         return false;
17     }

1 public void clear() {
2         modCount++;
3         for (int i = 0; i < size; i++)
4             elementData[i] = null;
5         size = 0;
6     }

1  public boolean removeAll(Collection<?> c) {
2          return batchRemove(c, false);//批量删除
3      }

 1 //这个方法，用于两处地方，如果complement为false，则用于removeAll；如果为true，则给retainAll()用
 2    private boolean batchRemove(Collection<?> c, boolean complement) {
 3         final Object[] elementData = this.elementData; //将原集合，记名为A
 4         int r = 0, w = 0;   //r用来控制循环，w是记录有多少个交集
 5         boolean modified = false;  
 6         try {
 7             for (; r < size; r++)
 8 //参数中的集合C一次检测集合A中的元素是否有，
 9                 if (c.contains(elementData[r]) == complement)
10 //有的话，就给集合A
11                     elementData[w++] = elementData[r];
12         } finally {
13 //如果contains方法使用过程报异常
14             if (r != size) {
15 //将剩下的元素都赋值给集合A，
16                 System.arraycopy(elementData, r, elementData, w, size - r);
17                 w += size - r;
18             }
19             if (w != size) {
20 //这里有两个用途，在removeAll()时，w一直为0，就直接跟clear一样，全是为null。
21 //retainAll()：没有一个交集返回true，有交集但不全交也返回true，而两个集合相等的时候，返回false，所以不能根据返回值来确认两个集合是否有交集，而是通过原集合的大小是否发生改变来判断，如果原集合中还有元素，则代表有交集，而元集合没有元素了，说明两个集合没有交集。
22           
23                 for (int i = w; i < size; i++)
24                     elementData[i] = null;
25                 modCount += size - w;
26                 size = w;
27                 modified = true;
28             }
29         }
30         return modified;
31     }