查看ArrayList的初始化
在创建ArrayList 集合的时候,如果不指定集合的长度,就走空参构造方法,在构造方法内部为 elementData属性赋初始值(DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
可以看到DEFAULTCAPACITY_EMPTY_ELEMENTDATA 的初始值是个空的数组。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
来到ArrayList类,找到add 方法;可以很清楚的看到该方法主要有三行代码:ArrayList集合中的add(E e)方法分析
一: 扩容操作;ensureCapacityInternal(size + 1);
二:执行 添加元素操作。elementData[size++] = e;
三:没有发生异常的话返回 true,说明添加成功
属性说明:
- elementData 用于存储数据的数组(也就说明了ArrayList底层使用数组实现的)
- size 表示集合中数据的的大小、数量
transient Object[] elementData;
private int size;
进入到ensureCapacityInternal方法查看
- 首先判断该数组是否为空;
- 初始化ArrayList集合的时候 elementData 数组是没有数据的,所以会走到if 语句里面;
- minCapacity 是传进来的形参,表示当前集合的容量大小;
- DEFAULT_CAPACITY 是ArrayList 提供的常量,默认容量 大小为10;
- 调用 Math.max 类的max 方法比较DEFAULT_CAPACITY 和minCapacity ,谁大就给 minCapacity 重新赋值;
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
Math的max方法代码
public static int max(int a, int b) {
return (a >= b) ? a : b;
}
执行完if 语句里面的代码后,调用ensureExplicitCapacity(int minCapacity)方法
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
- modCount 属性是ArrayList集合的抽象父类(AbstractList)提供的
- 想知道modCount 属性 是干嘛的可以访问以下这篇文章;
- modCount 自增之后 , if 语句判断 如果集合内元素的个数 减去 数组的长度 还大于 0 就调用 grow(minCapacity) 方法 执行扩容。
进入到grow(minCapacity) 方法查看
1. min capacity 这次扩容最小需要的容量
2. oldCapacity 扩容前原始数组容量
3. newCapacity是预计要扩容到的容量
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
进入到copyOf方法查看
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
再进入到重载的copyOf方法查看
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
进入到hugeCapacity(int minCapacity)方法查看
- 如果预计要扩容到的容量 减去 最大容量 大于0 则调用hugeCapacity 方法
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0)
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
完整代码
package cn.bloghut.linear;
import java.util.Arrays;
/**
* @author by 闲言
* @classname MyArrayList
* @description ArrayList-add(E e)方法源码
* @date 2021/7/14 11:07
*/
public class MyArrayList<E> {
/**
* 存储数据数组
*/
transient Object[] elementData;
/**
* 集合数据长度
*/
private int size;
/**
* 默认数据
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* 默认长度
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 最大容量--为了避免一些机器内存溢出,最大长度依然是Integer.MAX_VALUE,并不是Integer.MAX_VALUE-8
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 空参构造
*/
public MyArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 添加数据
*
* @param e
* @return
*/
public boolean add(E e) {
//在添加数据的时候调用 是否需要扩容
ensureCapacityInternal(size + 1);
//执行添加操作 size自增1(指针向后移动)
elementData[size++] = e;
return true;
}
/**
* 根据参数minCapacity,重置 elementData
*
* @param minCapacity
*/
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
/**
* 根据参数minCapacity,重置 elementData
*
* @param minCapacity
*/
private void ensureExplicitCapacity(int minCapacity) {
//minCapacity 减去 数组长度 大于0说明已经超出了数组的 存储空间,需要扩容了
if (minCapacity - elementData.length > 0) {
grow(minCapacity);
}
}
/**
* 动态扩容
*
* @param minCapacity
*/
private void grow(int minCapacity) {
//min capacity 这次扩容最小需要的容量
//oldCapacity 扩容前原始数组容量
int oldCapacity = elementData.length;
//newCapacity是预计要扩容到的容量
//oldCapacity >> 1 原数组右移 1位得到新值
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//复制数组
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0)
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
@Override
public String toString() {
return "MyArrayList{" +
"elementData=" + Arrays.toString(elementData) +
", size=" + size +
'}';
}
}