ArrayList源码分析

首先来总结一下，arraylist的一些特点：

　　1.arraylist本质上就是一个elementdata数组，它允许对元素进行快速随机访问，可以存放null值；

　　2.arraylist区别于数组的地方在于能够自动扩展大小，其中关键就是grow() 方法，每次扩充后数组为原来数组的1.5倍；

　　3.arraylist由于本质是数组，所以它在数据的查询方面会很快，而在插入删除方面，性能会下降很多，要移动很多数据才能达到应有的效果；

　　4.arraylist中的removeall(collection c)和clear() 的区别就是removeall可以删除批量指定的元素，而clear是全部删除集合中的元素；

　　5.arraylist实现了randomaccess，所以在遍历时推荐使用for循环；

　　6.arraylist是线程不安全的；

一、继承结构和层次关系

　　

　　

　　由图可以看出，arraylist 继承于abstractlist；abstractlist 继承于abstractcollection；所有类都继承于object。

1.为什么要先继承abstractlist，让abstractlist先实现list<e>，而不是让arraylist直接实现list<e>？

　　接口中全都是抽象的方法，而抽象类中可以有抽象方法，还可以有具体的实现方法，让abstractlist实现接口中一些通用的方法，而具体的类，如arraylist就继承这个abstractlist类，拿到一些通用的方法，然后自己再实现一些自己特有的方法。

2.arraylist实现了那些接口？

　　list<e>接口

　　randomaccedd接口：是一个标记性接口，作用是用来快速随机存取。若实现了该接口，使用普通的for循环来遍历，性能更高，例如arraylist。而没有实现该方法的接口，使用iterator来迭代，这样性能更高，例如linkedlist。

　　cloneable接口：实现了该接口，就可以使用object.clone()方法。

　　serializable接口：实现该序列化接口，表明该类可以被序列化。

二、构造方法

　　

1.无参构造方法

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         }

2.有参构造方法1

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     }

3.有参构造方法2（不常用）

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.add方法

　　

boolean add(e)；//默认直接在末尾添加元素

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     }

ensurecapacityinternal(xxx);

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     }

ensureexplicitcapacity(xxx);

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     }

grow(xxx);　　//arraylist核心的方法，能扩展数组大小的关键。

 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     }

hugecapacity();

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     }

 

void add(int ,e);　　//在特定的位置添加元素，也就是插入元素

 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     }

rangecheckforadd(index)

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

 

2.删除方法

　　

　　

　　

　remove(int) 方法：通过删除指定位置上的元素

 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     }

　remove(object)：这个方法可以看出来，arraylist是可以存放null值的。

 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     }

clear()：将elementdata中每个元素都赋值为null，等待垃圾回收将这个给回收掉，所以叫clear；

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

removeall(collection c)

1  public boolean removeall(collection<?> c) {
2          return batchremove(c, false);//批量删除
3      }

　　其中的batchremove(xx,xx)：用于两个方法，一个removeall()：它只清楚指定集合中的元素，retainall() 用来测试两个集合是否有交集。

 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     }