ArrayList源码分析-Java开发-Java web-我要学365体育投注人人小站_365体育投注打不开_皇冠365体育投注网址_我要学365体育投注人人小站_365体育投注打不开_皇冠365体育投注网址是一个面向开发者的知识分享网站 365体育投注人人小站_365体育投注打不开_皇冠365体育投注网址
我的位置:首页 > Java开发>Java web

ArrayList源码分析

时间:2019-11-08 19:48:00 来源:互联网 作者: 神秘的大神 字体:

首先来总结一下,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,而不是让ArrayList直接实现List

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

2.ArrayList实现了那些接口?

  List接口

  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继承了Person,那么根据这个构造方法,我就可以把这个Collection转换为ArrayList这就是这个构造方法的作用 
2      public ArrayList(Collectionextends 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     }