ArrayList扩容以及源码理解
前言
我出来工作了，各位好博友，在业余的时间研究了下ArrayList的底层，为了检验是否真的掌握了，特地仿写了ArrayList，并将其命名为MyArrayList
ArrayList 扩容机制与仿写ArrayList
ArrayList 扩容机制
先从简单介绍下ArrayList，它的底层数据结构是用数组实现的，我们一般叫动态数组。因为它是可以扩容的，可以用ensureCapacity（）来操作ArrayList实例的容量。
从ArrayList的构造器说起
private static final long serialVersionUID = 8683452581122892189L;
/**
* 默认容量为10【这里并不是说，你以new ArrayList，它的容量就是10，我们往下细细品】
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 空串
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 之所以写这个，把它从空串中独立出来，以便知道在添加第一个元素时容量需要增加多少
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* 用来存储元素（内容），之所以transient关键字修饰，是因为有些元素内容不能被序列化
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* ArrayList包含的元素个数
*/
private int size;
/**
*用户指定容量构造器
*/
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {//如果传入的容量大于0，new 除这个容量的数组并将其赋值给成员变量elementData
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {//如果传入容量的变量值是0，那便把空串赋值给成员变量
this.elementData = EMPTY_ELEMENTDATA;
} else {//如果两个都不是，抛出异常
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
/**
* 空参构造器，直接把默认空串赋值给elementData
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
*将集合转成ArrayList
*/
public ArrayList(Collection<? extends E> c) {
Object[] a = c.toArray();//将集合转成Object数组
if ((size = a.length) != 0) {//将数组的长度赋值给size，并判断是否不为0；如果不为0
if (c.getClass() == ArrayList.class) {//则集合c类型判断是不是ArrayList，是ArrayList就直接将数组a赋值给ArrayList的当前实例
elementData = a;
} else {//如果集合的类型不是ArrayList，将a数组复制，赋值长度为size，并返回赋值给成员变量
elementData = Arrays.copyOf(a, size, Object[].class);
}
} else {//传入的集合容量为0，赋值给null
// replace with empty array.
elementData = EMPTY_ELEMENTDATA;
}
}
当我们new ArrayList（）时，这是调用的是ArrayList的空参构造器。
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//这个是空串
}
这个时候ArrayList的size是0，因为现在ArrayList的底层数组中没有存任何元素（内容），也就是现在ArrayList的容量为0。那当我们add()方法添加一个元素，ArrayList的容量是1吗？
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;//记录修改次数，方便迭代器操作
// overflow-conscious code
if (minCapacity - elementData.length > 0)//在这里也许会困惑，为什么不直接minCapacity>0，其实这样写是因为考虑到了整数溢出问题
grow(minCapacity);
}
代码分析：
- 当我们以空参构造器创建ArrayList是，容量为0，当添加第一个元素的时候，ArrayList的容量扩展为10.
先看add()方法—》ensureCapacityInternal(size + 1)----》ensureExplicitCapacity(calculateCapacity(elementData, minCapacity))–》再看 calculateCapacity(Object[] elementData, int minCapacity)private static int calculateCapacity(Object[] elementData, int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//判断当前实例存储元素是不是空串，是空串【第一次添加肯定是】 return Math.max(DEFAULT_CAPACITY, minCapacity);//返回默认容量与需要扩容最小量【第一次添加 肯定是默认容量10大于1】 } return minCapacity; } - 返回后进入ensureExplicitCapacity（10），看ensureExplicitCapacity方法
private void ensureExplicitCapacity(int minCapacity) {
modCount++;//记录修改次数，方便迭代器操作
// 整数溢出问题
if (minCapacity - elementData.length > 0)//10 - 0 > 0进入grow方法
grow(minCapacity);
}
- 看grow方法
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length; //0
int newCapacity = oldCapacity + (oldCapacity >> 1);//1.5被扩容
if (newCapacity - minCapacity < 0)//0 - 10 < 0
newCapacity = minCapacity; //将10赋值给newCapacity
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);
}
第一次添加elementData.length为0，0>>1 为0 0+0 = 0 所以newCapacity 也为0，接着判断新容量是否大于最小扩容量【第一次是true】，将最小扩容量赋值给新容量，接着判断新容量收否大于最大数组容量（private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;），大于进入hugeCapacity方法，这里不大于所以不进入；接着创建新数组，新数组长度newCapacity，并将当前实例已有的内容赋值到新数组中，返回新数组 ，赋值给成员变量；
4. 扩容后就把元素放进去，修改size值
我们还可以看到底层是1.5被扩容【int newCapacity = oldCapacity + (oldCapacity >> 1);】
详解grow（）扩容
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//1.5倍扩容
if (newCapacity - minCapacity <0){
newCapacity = minCapacity;
}
if (newCapacity - MAX_ARRAY_SIZE>0){
newCapacity = hugeCapacity(minCapacity);
}
elementData =Arrays.copyOf(elementData,newCapacity);
}
oldCapacity 为旧容量，newCapacity 为新容量
位运算：右移一位，相当于除以2
oldCapacity + (oldCapacity >> 1) = 旧容量+（旧容量/2） = 旧容量的1.5倍
(newCapacity - minCapacity <0) 判断新容量是否大于最小扩容量，这样写是为了防止整数溢出问题【不直接写newCapacity >minCapacity 】
如果newCapacity 小于minCapacity 那就将最小扩容量赋值给新容量，如果大于进入下个判断
newCapacity - MAX_ARRAY_SIZE>0 判断新容量是否大于最大数值长度，大于进入hugeCapacity方法
private int hugeCapacity(int minCapacity) {
if (minCapacity<0){//最小扩容量为0，不合法；抛出异常
throw new OutOfMemoryError();
}
return (minCapacity>MAX_ARRAY_SIZE)?Integer.MAX_VALUE:MAX_ARRAY_SIZE;//最小扩容量如果大于最大数值长度，赋值给整数最大值，不大于赋值给最大数值长度
}
创建新数组，新数组长度newCapacity，并将当前实例已有的内容赋值到新数组中，返回新数组 ，赋值给成员变量；
MyArrayList 【仿造ArrayList】
这个是为了检验我是否懂的ArrayList而写的。里面也有很多对ArrayList理解，希望能对大家有帮助！
package com.ming;
import java.util.Arrays;
import java.util.Collection;
import java.util.Objects;
/**
* @author: Mr.ming
* @describe: NULL
* @create: 2023/11/18-21:18
*/
public class MyArrayList<E> {
//默认容量
private static final int DEFAULT_CAPACITY =10;
//存储数据，之所以用transient修饰，考虑到存储内容有些东西不能被序列化
transient Object[] elementData;
//空串
private static final Object[] EMPTY_ELEMENTDATA={};
//之所以写这个，把它从空串中独立出来，以便知道在添加第一个元素时容量需要增加多少
private static final Object[] DEFAULT_CAPACITY_EMPTY_ELEMENTDATA={};
private int size;
public MyArrayList() {
this.elementData = DEFAULT_CAPACITY_EMPTY_ELEMENTDATA;
}
public MyArrayList(int initialCapacity) {
if (initialCapacity>0){
elementData = new Object[initialCapacity];
}else if (initialCapacity == 0){
elementData =EMPTY_ELEMENTDATA;
}else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
//是为了缩容
public void trimToSize(){
if (size< elementData.length){//元素的长度小于容量大小
elementData = (size == 0)?
EMPTY_ELEMENTDATA://如果size等于0那就缩为空串
Arrays.copyOf(elementData,size);//如果不是的话，那就把真实的元素复制过去
}
}
public void ensureCapacity(int minCapacity){
//在这个变量中，我卡了很久，试图给这个变量一个具体的意义，但这是错的
//这个变量的作用就在于标志着你这个当前实例是否为空串，如果是空串，那就先初始化容量为10，避免频繁的扩容
//如果不为空串，那就标志为0，你不需要具体去了解为什么是0，而不是1，2，3，4等等这些，它的意义其实就是标志
int minExpend =elementData != DEFAULT_CAPACITY_EMPTY_ELEMENTDATA?
0:
DEFAULT_CAPACITY;
//当他不是空串，并且容量不够的情况下，才需要扩容；着说明它的容量一开始可能为10但是现在已经不够了，如果第一从的话，那就会默认为10不需要扩容
//不够就扩容，在这里不要试图去理解这个minExpend值是什么
if (minCapacity > minExpend){
ensureExplicitCapacity(minCapacity);
}
}
/**
* 判断是否需要扩容
* @param minCapacity
*/
private void ensureExplicitCapacity(int minCapacity) {
if (minCapacity - elementData.length>0){//他们为什么不minCapacity>elementData.length这样写，因为考虑到了整数溢出问题
grow(minCapacity);
}
}
//要分配的最大数值的大小
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 扩容
* @param minCapacity
*/
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//1.5倍扩容
if (newCapacity - minCapacity <0){
newCapacity = minCapacity;
}
if (newCapacity - MAX_ARRAY_SIZE>0){
newCapacity = hugeCapacity(minCapacity);
}
elementData =Arrays.copyOf(elementData,newCapacity);
}
private int hugeCapacity(int minCapacity) {
if (minCapacity<0){
throw new OutOfMemoryError();
}
return (minCapacity>MAX_ARRAY_SIZE)?Integer.MAX_VALUE:MAX_ARRAY_SIZE;
}
/**
*返回此列表中的元素数。
*/
public int size() {
return size;
}
public boolean isEmpty(){
return size == 0;
}
public boolean contains(Object o) {
return index(o) >= 0;
}
private int index(Object o) {
if (o == null){//将等于null的判断单独拎出来是为了优化性能和提高程序的效率,避免了多次调用equals
for (int i = 0; i <size ; i++) {
if (elementData[i] == null) {
return i;
}
}
}else {
for (int i = 0; i < size; i++) {
if (o.equals(elementData[i])){
return i;
}
}
}
return -1;
}
/**
* 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。.
*/
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size-1; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
public Object clone() {
try {
MyArrayList v = (MyArrayList)super.clone();
v.elementData = Arrays.copyOf(elementData,size);
return v;
}catch (CloneNotSupportedException e){
// 这不应该发生，因为我们是可以克隆的
throw new InternalError(e);
}
}
public Object[] toArray() {
return Arrays.copyOf(elementData,size);
}
@SuppressWarnings("unchecked")
public <E> E[] toArray(E[] a) {
if (a.length<size){
return (E[])Arrays.copyOf(elementData,size,a.getClass());
}
System.arraycopy(elementData,0,elementData,0,size);
if(a.length>size){
a[size] = null;
}
return a;
}
E elementData(int index) {
return (E) elementData[index];
}
public E get(int index) {
return (E) elementData[index];
}
public E set(int index, E element) {
rangeCheck(index);//检查下标是否越界
E oldElement = (E) elementData[index];
elementData[index] = element;
//返回原来的数据
return oldElement;
}
private void rangeCheck(int index) {
if (index>=size){
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
}
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size;
}
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
//这里看到ArrayList添加元素的实质就相当于为数组赋值
elementData[size++] = e;
return true;
}
//判断是否需要扩容
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULT_CAPACITY_EMPTY_ELEMENTDATA){
return Math.max(DEFAULT_CAPACITY,minCapacity); //默认容量与传入扩容参数的最大值，之所以这样，是因为，如果你是第一次添加元素就赋值为10，避免多次扩容
}
return minCapacity;
}
//删除元素
public E remove(int index) {
rangeCheck(index);
E oldElement = (E) elementData[index];
//判断要将下标移动多少位
int moveNum = size - index - 1;
//在这里我有的想法是用for循环将数组赋值，但是源码上是直接用现成方法复制
if (moveNum > 0){//如果等于或小于0，那便不用操作了，因为，等于0代表着删除的是末尾元素
System.arraycopy(elementData,index+1,elementData,index,moveNum);
}
elementData[--size] = null;
return oldElement;
}
public boolean remove(Object o) {
if (o == null){//在这里，不要忘记了ArrayList是可以存储null值的,将他单独拎出来，是因为避免了，多次调用equals方法，提升性能
for (int index = 0; index < size; index++) {
if (elementData[index] == null){
fastRemove(index);
return true;
}
}
}else {
for (int index = 0; index < size; index++) {
if (elementData[index].equals(o)){
fastRemove(index);
return true;
}
}
}
return false;
}
private void fastRemove(int index) {
int moveNum = size - index - 1;
if (moveNum > 0){
System.arraycopy(elementData,index+1,elementData, index, moveNum);
}
elementData[--size] = null;
}
public void clear() {
for (int i = 0; i < size; i++) {
elementData[i] = null;
}
size = 0;
}
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size+numNew);//判断是否需要扩容
System.arraycopy(a,0,elementData,size,numNew);
size += numNew;
return numNew != 0; //如果numNew 为0 时，证明传入的集合为空，那就添加失败。
}
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);//检查下标
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size+numNew);//扩容
int moveNum = size - index - 1;
if (moveNum>0){
System.arraycopy(elementData,0,elementData,index+numNew,moveNum);
}
System.arraycopy(a,0,elementData,index,numNew);
size += numNew;
return numNew != 0;
}
private void rangeCheckForAdd(int index) {
if (index > size || index < 0){
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
}
protected void removeRange(int fromIndex, int toIndex) {
int moveNum = size - toIndex;
System.arraycopy(elementData,toIndex,elementData,fromIndex,moveNum);
int newLength = size - (toIndex - fromIndex);
for (int i = newLength; i <size ; i++) {
}
}
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
//如果此列表被修改则返回true
return batchRemove(c, false);
}
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r= 0,w =0;
//记录修改情况
boolean modified = false;
try {
for (; r < size; r++) {
if (c.contains(elementData[r]) == complement){
elementData[w++] = elementData[r];
}
}
}finally {
if (r!=size){//如果r!=size 证明for循环没有处理完，可能出错了，那便把它全部复制到数组后面
System.arraycopy(elementData,r,elementData,w,size-r);
w += size - r;
}
if (w != size){
for (int i = w; i < size; i++) {
elementData[i] = null;
size = w;
modified = true;
}
}
}
return modified;
}
}
346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
