【集合】- ArrayList源码解析

ArrayList源码解析

  • 简介
    • 概述
    • 类图-继承关系
  • ArrayList的实现
    • 属性
    • 构造方法
      • 1. ArrayList()无参构造方法
      • 2. ArrayList(int initialCapacity)
      • 3. ArrayList(Collection c)
    • 常用方法
      • 1. add(E e) 方法
      • 2. add(int index, E element) 方法
      • 3. addAll(Collection c) 方法
      • 4. addAll(int index, Collection c) 方法
      • 5. remove(int index)方法
      • 6. fastRemove(Object[] es, int i)快速删除
      • 7. indexOf(Object o)查找单个元素
      • 8. lastIndexOf(Object o) 方法
      • 9. clone() 方法
      • 10. grow()扩容方法
      • 11. set(int index, E element)方法
      • 12. get(int index) 方法
  • 常见问题
  • 总结

简介

概述

ArrayList底层是一个数组,数组元素类型为object,支持动态扩容,所以ArrayList也相当于一个动态数组;ArrayList继承自 AbstractList,实现了 List 接口,允许 null 的存在;

接下来我们通过类层次结构、构造方法及常用方法三方面看ArrayList源码;

类图-继承关系

【集合】- ArrayList源码解析_第1张图片
ArrayList继承了AbstractList,实现了List、RandomAccess、Serializable、Cloneable这些接口;

  • List:是一个数组队列,提供了相关的添加、删除、修改、遍历等操作;
  • RandomAccess:提供了随机访问功能,ArrayList中可以通过元素序号快速获取元素对象;
  • Serializable:表示ArrayList支持序列化
  • Cloneable:支持克隆

ArrayList的实现

属性

    /**
     * 存储ArrayList元素的数组,
     * 添加到 ArrayList 中的元素数据(第一次添加元素时,空ArrayList会扩容到 DEFAULT_CAPACITY = 10 )
     */
    transient Object[] elementData;

    /**
     * ArrayList大小,包含元素数量
     */
    private int size;

构造方法

构造方法 构造方法描述
ArrayList() 构造一个初始容量为10的空列表
ArrayList(int initialCapacity) 构造具有指定初始容量的空列表
ArrayList(Collection c) 构造一个包含指定集合的元素的列表,按照它们由集合的迭代器返回的顺序

1. ArrayList()无参构造方法

DEFAULTCAPACITY_EMPTY_ELEMENTDATA,使用无参构造方法创建ArrayList数组的时候,是一种懒加载模式,创建的时候不设置大小,而是在使用的时候设置大小;

//默认初始化容量
private static final int DEFAULT_CAPACITY = 10;
//用于空实例的共享空数组实例,从0开始,按照1.5倍扩容
private static final Object[] EMPTY_ELEMENTDATA = {};

//共享的空数组对象,用户ArrayList() 构造方法,和EMPTY_ELEMENTDATA区分开,在第一次添加元素时,首次扩容为10
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

2. ArrayList(int initialCapacity)

根据传入的初始化容量,创建Array数组,如果传入参数是大于等于0,则使用用户的参数初始化,如果传入参数小于0,则抛异常;

public ArrayList(int initialCapacity) {
	//初始化容量>0时,创建Object数组
	if (initialCapacity > 0) {
	     this.elementData = new Object[initialCapacity];
	 //初始化容量=0时,使用EMPTY_ELEMENTDATA对象
	 } else if (initialCapacity == 0) {
	     this.elementData = EMPTY_ELEMENTDATA;
	 //初始化容量<0时,抛IllegalArgumentException异常
	 } else {
	     throw new IllegalArgumentException("Illegal Capacity: "+
	                                        initialCapacity);
	 }
}

3. ArrayList(Collection c)

构造一个包含指定集合元素的列表,这些元素按照 collection 集合迭代器返回的顺序排列的

/**
 * 按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表
 */
public ArrayList(Collection<? extends E> c) {
	//将C 转换为 object 数组
    Object[] a = c.toArray();
    if ((size = a.length) != 0) {
    	//判断集合元素是否为 Object[]类型,不是的话,会创建新的 Object[]数组,并把 elementData 赋值到新数组中,最后赋值给 elementData
        if (c.getClass() == ArrayList.class) {
            elementData = a;
        } else {
            elementData = Arrays.copyOf(a, size, Object[].class);
        }
    //如果数组size = 0 ,则直接将空对象 EMPTY_ELEMENTDATA 
    } else {
        // replace with empty array.
        elementData = EMPTY_ELEMENTDATA;
    }
}

常用方法

1. add(E e) 方法

顺序添加单个元素到数组

/**
 * 在列表末尾添加元素
 */
public boolean add(E e) {
	//增加数组操作次数
    modCount++;
    //添加元素
    add(e, elementData, size);
    return true;
}
private void add(E e, Object[] elementData, int s) {
    //如果容量不够,进行扩容
    if (s == elementData.length)
        elementData = grow();
    //设置到末尾
    elementData[s] = e;
    //数量大小加一
    size = s + 1;
}

2. add(int index, E element) 方法

插入单个元素到指定位置

public void add(int index, E element) {
    // 校验位置是否在数组范围内
    rangeCheckForAdd(index);
    // 增加数组修改次数
    modCount++;
    //如果数组大小不够,进行扩容
    final int s;
    Object[] elementData;
    if ((s = size) == (elementData = this.elementData).length)
        elementData = grow();
    //将 index + 1 位置开始的元素,进行往后挪
    System.arraycopy(elementData, index,
                     elementData, index + 1,
                     s - index);
    //设置到指定位置
    elementData[index] = element;
    //数组大小加一
    size = s + 1;
}
private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

3. addAll(Collection c) 方法

批量添加多个元素,如果明确知道会添加多个元素时,使用该方法,避免使用单个元素添加带来的多次扩容;

public boolean addAll(Collection<? extends E> c) {
    //转成 a 数组
    Object[] a = c.toArray();
    //增加操作次数
    modCount++;
    //如果 a 数组大小为 0 ,返回 ArrayList 数组无变化
    int numNew = a.length;
    if (numNew == 0)
        return false;
    //如果 elementData 剩余的空间不够,则进行扩容。要求扩容的大小,至于能够装下 a 数组。
    Object[] elementData;
    final int s;
    if (numNew > (elementData = this.elementData).length - (s = size))
        elementData = grow(s + numNew);
    //将 a 复制到 elementData 从 s 开始位置
    System.arraycopy(a, 0, elementData, s, numNew);
    //数组大小加 numNew
    size = s + numNew;
    return true;
}

4. addAll(int index, Collection c) 方法

从指定位置开始批量添加多个元素

public boolean addAll(int index, Collection<? extends E> c) {
    rangeCheckForAdd(index);
    Object[] a = c.toArray();
    // 增加数组修改次数
    modCount++;
    //如果 a 数组大小为 0 ,返回 ArrayList 数组无变化
    int numNew = a.length;
    if (numNew == 0)
        return false;
    //如果 elementData 剩余的空间不够,则进行扩容,扩容的大小,至于能够装下 a 数组。
    Object[] elementData;
    final int s;
    if (numNew > (elementData = this.elementData).length - (s = size))
        elementData = grow(s + numNew);
    /**
     * 如果 index 开始的位置已经被占用,将原有元素向后移
     */ 
    int numMoved = s - index;
    if (numMoved > 0)
        System.arraycopy(elementData, index,
                         elementData, index + numNew,
                         numMoved);
    //将 a 复制到 elementData 从 s 开始位置
    System.arraycopy(a, 0, elementData, index, numNew);
    //数组大小加 numNew
    size = s + numNew;
    return true;
}

5. remove(int index)方法

删除index位处的数据

public E remove(int index) {
    //校验 index 不要超过 size
    Objects.checkIndex(index, size);
    final Object[] es = elementData;
    //记录该位置的原值
    @SuppressWarnings("unchecked") E oldValue = (E) es[index];
    //快速移除
    fastRemove(es, index);
    //返回该位置的原值
    return oldValue;
}

6. fastRemove(Object[] es, int i)快速删除

private void fastRemove(Object[] es, int i) {
    //增加数组修改次数
    modCount++;
    //如果 i 不是最末尾的元素,则将 i + 1 位置的数组往前挪
    final int newSize;
    if ((newSize = size - 1) > i) // -1: size 是从 1 开始,而数组下标是从 0 开始
    	//把i+1位后的 newSize-i的数据往前移一位
        System.arraycopy(es, i + 1, es, i, newSize - i);
    //末尾置为 null
    es[size = newSize] = null;
}

7. indexOf(Object o)查找单个元素

获取指定元素位置,找不到,返回-1

public int indexOf(Object o) {
    return indexOfRange(o, 0, size);
}
int indexOfRange(Object o, int start, int end) {
    Object[] es = elementData;
    //null 的情况
    if (o == null) {
    	//从start循环到end,如果数据为空,则返回对应下标
        for (int i = start; i < end; i++) {
            if (es[i] == null) {
                return i;
            }
        }
    //非 null 的情况
    } else {
        for (int i = start; i < end; i++) {
        	//调用目标函数的equals方法
            if (o.equals(es[i])) {
                return i;
            }
        }
    }
    return -1;
}

8. lastIndexOf(Object o) 方法

查找元素最后一次出现位置

public int lastIndexOf(Object o) {
	//范围内查询元素最后一次出现位置(即逆第一次出现位置)
    return lastIndexOfRange(o, 0, size);
}
int lastIndexOfRange(Object o, int start, int end) {
    Object[] es = elementData;
    if (o == null) {
        for (int i = end - 1; i >= start; i--) { // 倒序
            if (es[i] == null) {
                return i;
            }
        }
    } else {
        for (int i = end - 1; i >= start; i--) { // 倒序
            if (o.equals(es[i])) {
                return i;
            }
        }
    }
    return -1;
}

9. clone() 方法

克隆 ArrayList 对象

// ArrayList.java
public Object clone() {
    try {
        //调用父类,进行克隆
        ArrayList<?> v = (ArrayList<?>) super.clone();
        //拷贝一个新的数组
        v.elementData = Arrays.copyOf(elementData, size);
        //设置数组操作次数为0
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}

10. grow()扩容方法

创建一个新的更大的数组,然后将原数组复制到新数组中,最后返回新数组
以下是扩容核心代码:

//JDK 9
private Object[] grow() {
    //调用 #grow(int minCapacity) 方法,要求扩容后至少比原有大1 
    return grow(size + 1);
}
private Object[] grow(int minCapacity) {
    int oldCapacity = elementData.length;
    //如果原容量大于0 ,或者数组不是 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时,计算新的数组大小,并扩容
    if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        int newCapacity = ArraysSupport.newLength(oldCapacity,
                minCapacity - oldCapacity,
                oldCapacity >> 1 
        return elementData = Arrays.copyOf(elementData, newCapacity);
    //如果是 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 数组,直接创建新的数组
    } else {
        return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
    }
}
//JDK8
private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        //将 oldCapacity 右移一位,相当于 oldCapacity / 2
        //将容量更新为 原容量 的 1.5 倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //判断 新容量 与 最小需要容量,如果新容量 < 最小需要容量,就把最小需要容量作为 新容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //如果 新容量 > MAX_ARRAY_SIZE,就 比较 minCapacity 和 MAX_ARRAY_SIZE
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        //如果 minCapacity > MAX_ARRAY_SIZE,则 新容量为 Integer.MAX_VALUE,否则为 MAX_ARRAY_SIZE
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
  • 初始化ArrayList数组时有无参,无参,则在添加第一个元素的时候,设置 newCapacity = minCapacity(10),当添加第 11 个元素时,进行扩容,执行 grow() 方法,newCapacity = 15,数组容量扩容至 15,size = 11;
  • 有参时,使用参数容量,添加元素时,判断 容量 够不够,容量满了进行扩容

“>>” 移位运算符:>>1 向右移一位相当于除以2,右移 N 位相当于除以2的 N 次方;
oldCapacity >> 1:oldCapacity 右移了一位,相当于 oldCapacity / 2;

11. set(int index, E element)方法

set(int index, E element)方法,设置指定位置的元素

public E set(int index, E element) {
    // 校验index不要超过 size
    Objects.checkIndex(index, size);
    // 获得index位置的原元素
    E oldValue = elementData(index);
    // 修改index位置为新元素
    elementData[index] = element;
    // 返回index位置的原元素
    return oldValue;
}

12. get(int index) 方法

get(int index) 方法获取指定位置的元素

public E get(int index) {
    Objects.checkIndex(index, size);
    //获得 index 位置的元素
    return elementData(index);
}
E elementData(int index) {
    return (E) elementData[index];
}

常见问题

总结

  • ArrayList本质是一个数组,动态数组,创建时可以指定初始化容量,当添加元素超过当前容量大小时,会调用grow()进行扩容;
  • 查询元素效率高,插入和删除元素效率不高

你可能感兴趣的:(#,jdk源码解析,源码,后端,arraylist,list,java)