(一)ArrayList集合源码解析

一、ArrayList的集合特点

 

问题 结      论
ArrayList是否允许空 允许
ArrayList是否允许重复数据 允许
ArrayList是否有序 有序
ArrayList是否线程安全 非线程安全

二、ArrayList的原理

  ArrayList底层是一个Object[] elementData数组,能够实现动态扩容,增减。

  从源码看ArrayList实现了RandomAccess, Cloneable,Serializable接口,RandomAccess用于快速存取提高循环的效率。Cloneable该接口可以实现对象的克隆方法。Serializable可以进行序列化,序列化是将对象的状态信息转换为可以存储或传输的形式的过程。

三、源码解析

1.属性和构造方法

  源码解析主要是从集合从增加元素,删除元素,查询元素,以及修改元素这几个常用方法进行解析。

  • ArrayList属性
1 transient Object[] elementData;//定义一个elementData数组
2 private int size;//size是数组大小实现数组增减size进行增减
  • ArrayList无参构造方法
1     /**
2      * Constructs an empty list with an initial capacity of ten.
3      */
4     public ArrayList() {
5         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//将elementData进行初始化elementData也是个Object[]类型。空的Object[]会给默认大小10
6     }
7     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
  • ArrayList有参构造方法
 1   public ArrayList(int initialCapacity) {
 2         if (initialCapacity > 0) {
 3             this.elementData = new Object[initialCapacity];//将自定义的容量大小当成初始化elementData的大小
 4         } else if (initialCapacity == 0) {
 5             this.elementData = EMPTY_ELEMENTDATA;//为0直接进行初始化
 6         } else {
 7             throw new IllegalArgumentException("Illegal Capacity: "+
 8                                                initialCapacity);//判断如果自定义大小的容量小于0,则报下面这个非法数据异常
 9         }
10     }
  • ArrayList(Collection<? extends E> c)构造方法
 1 //就是将个Collection转换为ArrayList
 2 public ArrayList(Collection<? extends E> c) {
 3         elementData = c.toArray();
 4         if ((size = elementData.length) != 0) {
 5             // c.toArray might (incorrectly) not return Object[] (see 6260652)
 6             if (elementData.getClass() != Object[].class)//进行对象校验
 7                 elementData = Arrays.copyOf(elementData, size, Object[].class);
 8         } else {
 9             // replace with empty array.
10             this.elementData = EMPTY_ELEMENTDATA;
11         }
12     }

2.add()方法

  1. add确保数组已使用长度(size), size+1确保之后足够存下 下一个数据。
  2. 如果当前数组已使用长度(size)加1后的大于当前的数组长度,则调用grow方法,增长数组,grow方法会将当前数组的长度变为原来容量的1.5倍。
  3. 当第一次添加元素的时候this.size+1 的值是1,所以第一次添加的时候会将当前elementData数组的长度变为10。
  4. 新增的数据有地方存储之后,则将新元素添加到位于size的位置上。
  5. 返回添加成功布尔值。
1    public boolean add(E e) {
2         ensureCapacityInternal(size + 1);  // Increments modCount!!  确定内部容量是否够了
3         elementData[size++] = e;//赋值
4         return true;
5     }

  从源码看add方法就是很正常的进行赋值的操作,这里ensureCapacityInternal是数组的核心下面进行详细介绍。

1     private static int calculateCapacity(Object[] elementData, int minCapacity) {
2         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
3             return Math.max(DEFAULT_CAPACITY, minCapacity);
4         }
5         return minCapacity;
6     }
//确保添加的元素有地方存储,当第一次添加元素的时候this.size+1 的值是1,所以第一次添加的时候会将当前elementData数组的长度变为10:

  数组扩容条件判断:当前所需的数组最小长度与数组的长度对比,如果大于0,则增长数组长度。

1     private void ensureExplicitCapacity(int minCapacity) {
2         modCount++;
3 
4         // overflow-conscious code
5         if (minCapacity - elementData.length > 0)
6             grow(minCapacity);
7     }

  数组扩容:

 1 private void grow(int minCapacity) {
 2         // overflow-conscious code
 3         int oldCapacity = elementData.length;  //将扩充前的elementData大小给oldCapacity
 4         int newCapacity = oldCapacity + (oldCapacity >> 1);//newCapacity就是1.5倍的oldCapacity
 5         if (newCapacity - minCapacity < 0)//elementData就空数组的时候,length=0,那么oldCapacity=0,newCapacity=0判断成立,初始化elementData的大小了,就是为10.
 6             newCapacity = minCapacity;
 7         if (newCapacity - MAX_ARRAY_SIZE > 0)//如果newCapacity超过了最大的容量限制,就调用hugeCapacity,也就是将能给的最大值给newCapacity
 8             newCapacity = hugeCapacity(minCapacity);
 9         // minCapacity is usually close to size, so this is a win:
10     //新的容量大小已经确定好了,就copy数组,改变容量大小咯。
11         elementData = Arrays.copyOf(elementData, newCapacity);
12     }

  hugeCapacity()用来赋最大值。

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

3.void add(int,E);在特定位置添加元素,也就是插入元素

  在制定位置赋值,主要进行以下步骤,arryList集合的核心是arraycopy这个,这个后面具体介绍。

  1. 判断索引有没有越界
  2. 自增修改次数
  3. 将指定位置(index)上的元素保存到oldValue
  4. 将指定位置(index)上的元素都往前移动一位
  5. 将最后面的一个元素置空,好让垃圾回收器回收
  6. 将原来的值oldValue返回
 1 public void add(int index, E element) {
 2         rangeCheckForAdd(index);//校验。
 3         ensureCapacityInternal(size + 1);  // Increments modCount!!
 4 //这个方法就是用来在插入元素之后,要将index之后的元素都往后移一位,
 5         System.arraycopy(elementData, index, elementData, index + 1,
 6                          size - index);
 7 //在目标位置上存放元素
 8         elementData[index] = element;
 9         size++;//size增加1
10     }  

4.remove(int):通过删除指定位置上的元素

   remove执行的方法如下:

  1. 判断索引有没有越界
  2. 自增修改次数
  3. 将指定位置(index)上的元素保存到oldValue
  4. .将指定位置(index)上的元素都往前移动一位
  5. 将最后面的一个元素置空
  6. 将原来的值oldValue返回
 1 public E remove(int index) {
 2         rangeCheck(index);//检查
 3         modCount++;//这个作用很多,比如用来检测快速失败(failfast)的一种标志。
 4         E oldValue = elementData(index);//通过索引直接找到该元素
 5         int numMoved = size - index - 1;//计算要移动的位数。
 6         if (numMoved > 0)
 7       //这个方法也已经解释过了,就是用来移动元素的。
 8             System.arraycopy(elementData, index+1, elementData, index,
 9                              numMoved);
10     //将--size上的位置赋值为null,让gc回收它。
11         elementData[--size] = null; // clear to let GC do its work
12     //返回删除的元素。
13         return oldValue;
14     }

 5.System.arrayCopy这个是数组的扩容的核心api

如图属性详解:

参数 说明
src 原数组
srcPos 原数组
dest 目标数组
destPos 目标数组的起始位置
length 要复制的数组元素的数目

 1 public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)//这个是native方法 

具体使用请查看这个案例:

int data[] = new int[]{1, 2, 3, 4};
int bigdata[] = new int[6];
System.arraycopy(data, 0, bigdata, 0, 4);
结果:{1,2,3,4,0,0}
如图所示:

四、总结:

  1. arrayList可以存放null。
  2. arrayList本质上就是一个elementData数组。
  3. arrayList中removeAll(collection c)和clear()的区别就是removeAll可以删除批量指定的元素,而clear是删除集合中的全部元素。
  4. arrayList由于本质是数组,所以它在数据的查询方面会很快,而在插入删除这些方面,性能下降很多。
  5. arrayList实现了RandomAccess,所以在遍历它的时候推荐使用for循环。
  6. arrayList的实质是System.arraycopy方法,arraycopy其实是浅拷贝。

 

 

 

  

posted @ 2019-09-17 16:51  咸鱼也要有梦想  阅读(302)  评论(2编辑  收藏