JAVA容器系列一：ArrayList源码解读

香气袭人知骤暖

已于 2022-05-10 15:54:31 修改

阅读量243

点赞数 1

分类专栏： java类库文章标签： java 容器开发语言

于 2019-04-03 21:45:28 首次发布

本文链接：https://blog.csdn.net/qq_34748010/article/details/89005709

版权

java类库专栏收录该内容

10 篇文章 1 订阅

订阅专栏

ArrayList是一个可动态扩展的列表，底层实现是数组。首先看一下该类的继关系，如下图：
在这里插入图片描述
从图中可以看到ArrayList类继承自AbstractList、而AbstractList类又继承自AbstractCollection；另外实现的接口有Collection、List、Cloneable、Serialzable、Iterable和RandomAccess。

ArrayList方法（API）

// Collection中定义的API
boolean             add(E object)
boolean             addAll(Collection<? extends E> collection)
void                clear()
boolean             contains(Object object)
boolean             containsAll(Collection<?> collection)
boolean             equals(Object object)
int                 hashCode()
boolean             isEmpty()
Iterator<E>         iterator()
boolean             remove(Object object)
boolean             removeAll(Collection<?> collection)
boolean             retainAll(Collection<?> collection)
int                 size()
<T> T[]             toArray(T[] array)
Object[]            toArray()
// AbstractCollection中定义的API
void                add(int location, E object)
boolean             addAll(int location, Collection<? extends E> collection)
E                   get(int location)
int                 indexOf(Object object)
int                 lastIndexOf(Object object)
ListIterator<E>     listIterator(int location)
ListIterator<E>     listIterator()
E                   remove(int location)
E                   set(int location, E object)
List<E>             subList(int start, int end)
// ArrayList新增的API
Object               clone()
void                 ensureCapacity(int minimumCapacity)
void                 trimToSize()
void                 removeRange(int fromIndex, int toIndex)

基础属性

private static final int DEFAULT_CAPACITY = 10; // 初始容量10
 
private static final Object[] EMPTY_ELEMENTDATA = {};   // 空实例数组
 
// 默认大小的空实例数组，在第一次调用ensureCapacityInternal时会初始化长度为10
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};   
 
transient Object[] elementData; // 存放元素的数组
 
private int size;   // 数组当前的元素数量
 
public ArrayList(int initialCapacity) { // 带容量参数的构造方法
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}
 
public ArrayList() {    // 不带容量参数则使用默认大小的空实例数组
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

}

Get方法

@SuppressWarnings("unchecked")
E elementData(int index) {
    return (E) elementData[index];
}
 
/**
 * Returns the element at the specified position in this list.
 *
 * @param  index index of the element to return
 * @return the element at the specified position in this list
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
public E get(int index) {   // 根据索引获取元素
    rangeCheck(index);  // 校验索引是否越界
 
    return elementData(index);  // 直接根据index返回对应位置的元素（底层elementData是个数组）

}

Set方法


public E set(int index, E element) {    // 用指定的元素（element）替换指定位置（index）的元素
    rangeCheck(index);  // 校验索引是否越界
 
    E oldValue = elementData(index);    // 根据index获取指定位置的元素
    elementData[index] = element;   // 用传入的element替换index位置的元素
    return oldValue;    // 返回index位置原来的元素
}

扩容

add方法在添加元素之前会先调用ensureCapacityInternal方法，主要是有两个目的：1.如果没初始化则进行初始化；2.校验添加元素后是否需要扩容。

// ensureCapacityInternal(size + 1);用minCapacity接收传入参数size+1
private void ensureCapacityInternal(int minCapacity) {
    // 校验当前数组是否为（默认的）DEFAULTCAPACITY_EMPTY_ELEMENTDATA，
    // 如果是则将minCapacity设为DEFAULT_CAPACITY（默认为10），
    // 主要是给DEFAULTCAPACITY_EMPTY_ELEMENTDATA设置初始容量
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { 
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
 
    ensureExplicitCapacity(minCapacity);
}
 
private void ensureExplicitCapacity(int minCapacity) {
    modCount++; // 修改次数+1
 
    // 如果添加该元素后的大小超过数组大小，则进行扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);  // 进行扩容
}
 
// 数组允许的最大长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; 
 
private void grow(int minCapacity) {    // 数组扩容
    // overflow-conscious code
    int oldCapacity = elementData.length;   // 原来的容量
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 新容量 = 老容量 + 老容量 / 2
    if (newCapacity - minCapacity < 0)  // 如果新容量比minCapacity小，
        newCapacity = minCapacity;  // 则将新容量设为minCapacity，兼容初始化情况
    if (newCapacity - MAX_ARRAY_SIZE > 0)   // 如果新容量比最大允许容量大，
        newCapacity = hugeCapacity(minCapacity);    // 则调用hugeCapacity方法设置一个合适的容量
    // 将原数组元素拷贝到一个容量为newCapacity的新数组（使用System.arraycopy），
    // 并且将elementData设置为新数组
    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;
}

Add方法

/**
 * Appends the specified element to the end of this list.
 *
 * @param e element to be appended to this list
 * @return <tt>true</tt> (as specified by {@link Collection#add})
 */
public boolean add(E e) {  //将指定元素添加到列表末尾
    ensureCapacityInternal(size + 1);  // 将modCount+1，并校验添加元素后是否需要扩容
    // 需要注意的是,这儿使用的是后加加,因为下标从0开始,新加元素的下标刚好等于集合长度
    elementData[size++] = e;    //  在数组尾部添加元素，并将size+1
    return true;
}
 
/**
 * Inserts the specified element at the specified position in this
 * list. Shifts the element currently at that position (if any) and
 * any subsequent elements to the right (adds one to their indices).
 *
 * @param index index at which the specified element is to be inserted
 * @param element element to be inserted
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
public void add(int index, E element) { // 将指定的元素（element）插入此列表中的指定位置（index）。将index位置及后面的所有元素（如果有的话）向右移动一个位置
    rangeCheckForAdd(index);    // 校验索引是否越界
 
    ensureCapacityInternal(size + 1);  // 将minCapacity+1，并校验添加元素后是否需要扩容
    System.arraycopy(elementData, index, elementData, index + 1,    // 将index位置及之后的所有元素向右移动一个位置（为要添加的元素腾出1个位置）
                     size - index);
    elementData[index] = element;   // index位置设置为element元素
    size++; // 元素数量+1
}

Remove方法

public E remove(int index) {    // 删除列表中index位置的元素，将index位置后面的所有元素向左移一个位置
    rangeCheck(index);  // 校验索引是否越界
 
    modCount++; // 修改次数+1
    E oldValue = elementData(index);    // index位置的元素，也就是将要被移除的元素
 
    int numMoved = size - index - 1;    // 计算需要移动的元素个数，例如：size为10，index为9，此时numMoved为0，则无需移动元素，因为此时index为9的元素刚好是最后一个元素，直接执行下面的代码，将索引为9的元素赋值为空即可
    if (numMoved > 0)   // 如果需要移动元素
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved); // 将index+1位置及之后的所有元素，向左移动一个位置
    elementData[--size] = null; // 将size-1，并将size-1位置的元素赋值为空（因为上面将元素左移了，所以size-1位置的元素为重复的，将其移除）
 
    return oldValue;    // 返回index位置原来的元素
}
 
public boolean remove(Object o) {   // 如果存在与入参相同的元素，则从该列表中删除指定元素的第一个匹配项。如果列表不包含元素，则不变
    if (o == null) {    // 如果入参元素为空，则遍历数组查找是否存在元素为空，如果存在则调用fastRemove将该元素移除，并返回true表示移除成功
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {    // 如果入参元素不为空，则遍历数组查找是否存在元素与入参元素使用equals比较返回true，如果存在则调用fastRemove将该元素移除，并返回true表示移除成功
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;   // 不存在目标元素，返回false
}
 
/*
 * Private remove method that skips bounds checking and does not
 * return the value removed.
 */
private void fastRemove(int index) {    // 私有方法，供上面的remove方法调用，直接删除掉index位置的元素
    modCount++; // 修改次数+1
    int numMoved = size - index - 1; // 计算需要移动的元素个数，例如：size为10，index为9，此时numMoved为0，则无需移动元素，因为此时index为9的元素刚好是最后一个元素，直接执行下面的代码，将索引为9的元素赋值为空即可
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved); // 将index+1位置及之后的所有元素，向左移动一个位置
    elementData[--size] = null; // 将size-1，并将size-1位置的元素赋值为空（因为上面将元素左移了，所以size-1位置的元素为重复的，将其移除）
}

ArrayList和LinkedList比较

1、ArrayList底层基于动态数组实现，LinkedList底层基于链表实现
2、对于随机访问（get/set方法），ArrayList通过index直接定位到数组对应位置的节点，而LinkedList需要从头结点或尾节点开始遍历，直到寻找到目标节点，因此在效率上ArrayList优于LinkedList
3、对于插入和删除（add/remove方法），ArrayList需要移动目标节点后面的节点（使用System.arraycopy方法移动节点），而LinkedList只需修改目标节点前后节点的next或prev属性即可，因此在效率上LinkedList优于ArrayList。

——————————————————————————————————

手写ArrayList集合代码

一、自定义List接口

package com.list;
 
public interface MyAbstractList<E> {
	public void add(E object);
	
	public void add(int index,E object);
	
	public boolean remove(E object);
	
	public Object remove(int index);
	
	public int getSize();
	
	public Object get(int index);
}

二.自定义ArrayList集合

package com.list;
 
import java.util.Arrays;
 
public class MyArrayList<E> implements MyAbstractList<E>{
	// ArrayList底层采用数组存放
	private transient Object[] elementData;
	// 默认数组容量
    private static final int DEFAULT_CAPACITY = 10;
	// ArrayList实际存储的数据数量
	private int size;
	
	//构造方法
	public MyArrayList() {
		this(DEFAULT_CAPACITY);
	}
	
	public MyArrayList(int initialCapacity) {
		if(initialCapacity<0)
			throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
		elementData = new Object[initialCapacity];
			
	}
 
	public void add(E object) {
		// TODO Auto-generated method stub
		ensureExplicitVapacity(size+1);
		elementData[size++]=object;
		
	}
 
	public void add(int index, E object) {
		// TODO Auto-generated method stub
		//int i;
		rangeCheck(index);
		ensureExplicitVapacity(size+1);
		System.arraycopy(elementData, index, elementData, index+1, size);
		/*for(i=size;i>index-1;i--) {
		elementData[i+1]=elementData[i];
	}*/
		
		elementData[index]=object;
		size++;
		
	}
 
	public boolean remove(E object) {
		// TODO Auto-generated method stub
		for(int i=0;i<size;i++){
			Object element=elementData[i];
			if(element.equals(object)){
				remove(i);
				return true;
			}
		}
		return false;
	}
	
	public Object remove(int index) {
		// TODO Auto-generated method stub
		Object object=get(index);
		int numMoved = size-index-1;
		if(numMoved>0){
			System.arraycopy(elementData, index+1, elementData, index, numMoved);
		}
		elementData[--size]=null;
		return object;
	}
 
	public int getSize() {
		// TODO Auto-generated method stub
		return size;
	}
 
	public Object get(int index) {
		// TODO Auto-generated method stub
		rangeCheck(index);
		return elementData[index];
	}
 
	/**
	 * 扩容
	 * @param minCapacity
	 */
	public void ensureExplicitVapacity(int minCapacity){
		//if(size==minCapacity){
		if (minCapacity - elementData.length > 0){
			int oldCapacity=elementData.length;
			int newCapacity=oldCapacity+(oldCapacity >>1);
			if(newCapacity<minCapacity){
				newCapacity=minCapacity;
			}
			elementData=Arrays.copyOf(elementData,newCapacity);
		}
			
	}
	/**
	 * 检测数组是否下标越界
	 * @param index
	 */
	private void rangeCheck(int index) {
		if (index >= size) {
			throw new IndexOutOfBoundsException("length--->"+index);
		}
	}
 }

香气袭人知骤暖

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA容器系列一：ArrayList源码解读

基础属性private static final int DEFAULT_CAPACITY = 10; // 初始容量10 private static final Object[] EMPTY_ELEMENTDATA = {}; // 空实例数组 // 默认大小的空实例数组，在第一次调用ensureCapacityInternal时会初始化长度为10private static ...
复制链接

扫一扫