集合-ArrayList源码分析

ArrayList是Java集合框架中较为常用的一种数据结构.下面来介绍一下它.

继承关系:

ArrayList继承了AbstractList,实现了List,RandomAccess(随机访问),Cloneable,Serializable接口

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, 
        	RandomAccess,
        	 Cloneable,
        	  java.io.Serializable{
}

底层数据结构:

数组(可调整大小的数组)

transient Object[] elementData; 

特点:

数组结构的优点: 查询快(随机访问)
缺点: 增删慢(涉及到数据的移动)

源码分析:

属性

    /**
    * 默认初始容量
    */
    private static final int DEFAULT_CAPACITY = 10;
    /**
    * 空数组
    */
    private static final Object[] EMPTY_ELEMENTDATA = {};
    /**
    * 默认容量的空数组
    */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    /**
    * 集合真正存储数组元素的数组
    */
    transient Object[] elementData;
    /**
    * 集合的大小
    */
    private int size;

构造方法(ArrayList):

1. 无参构造:

public ArrayList() {
    //默认空容量的数组 ,长度为0
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; 
}

通过空参构造方法创建集合对象并未构造一个初始容量为十的空列表,仅仅将DEFAULTCAPACITY_EMPTY_ELEMENTDATA 的地址赋值给elementData

2. 有参数构造 :

public ArrayList(int initialCapacity) { //initialCapacity = 5
    //判断初始容量initialCapacity是否大于0
    if (initialCapacity > 0) {
        //创建一个数组,且指定大小为initialCapacity
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        //如果initialCapacity容量为0,把elementData指向EMPTY_ELEMENTDATA
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        //都不满足则抛异常
        throw new IllegalArgumentException("Illegal Capacity: "+
                                   initialCapacity);
    }
}

根据传入的参数确定容器的大小.

3. 可传入一个集合容器.

public ArrayList(Collection<? extends E> c) {
    // 将集合c转数组,将elementData指向数组的地址
    elementData = c.toArray();
    // 获取elementData集合长度赋值给size,且判断是否不等于 0
    if ((size = elementData.length) != 0) {
    // 判断elementData 和 Object[] 是否为不一样的类型
        if (elementData.getClass() != Object[].class){
            //若不一样,使用Arrays的copyOf方法进行copy
            elementData = Arrays.copyOf(elementData, size, Object[].class);
        }
    } else {
        // 数组长度为0,用空数组代替
        this.elementData = EMPTY_ELEMENTDATA;
    }
}
//将集合转数组的方法
public Object[] toArray() {
    //调用数组工具类方法进行拷贝
    return Arrays.copyOf(elementData, size);
}

Arrays工具类

//数组工具类
public static <T> T[] copyOf(T[] original, int newLength) {
    //调用方法进行拷贝
    return (T[]) copyOf(original, newLength, original.getClass());
}

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    //用三元运算符进行判断,会创建一个新数组
    T[] copy = ((Object)newType == (Object)Object[].class)
                ? (T[]) new Object[newLength]
                : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    //将原数组数组的内容拷贝到 copy 该数组中
    System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));
    //返回拷贝元素成功后的数组
    return copy;
}

添加方法(add):

add(E e)

public boolean add(E e) {
    //对内部容量进行检测
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}
private void ensureCapacityInternal(int minCapacity) {
    //判断集合存数据的数组是否等于空容量的数组
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //通过最小容量和默认容量 求出较大值 (用于第一次扩容) 大小会为10
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //minCapacity给下一个方法,继续检验
    ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
    //记录操作集合的次数 (主要用于迭代器)
    modCount++;
    //判断最小容量 - 数组长度是否 > 0
    if (minCapacity - elementData.length > 0) {
        //将minCapacity的值传递给 grow方法
        grow(minCapacity);
    }
}
private void grow(int minCapacity) {
    //记录数组的实际长度,此时由于没有存储元素,长度为0
    int oldCapacity = elementData.length;
    //核心扩容 : 1.5倍扩容
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //判断新容量 - 最小容量 是否小于 0, (第一次调用add方法必然小于 0)
    if (newCapacity - minCapacity < 0)
        //还是将最小容量赋值给新容量
        newCapacity = minCapacity;
    //判断新容量- 最大数组大小 是否>0,如果条件满足就计算出一个超大容量
    if (newCapacity - MAX_ARRAY_SIZE > 0) //一般不会为true
        newCapacity = hugeCapacity(minCapacity);

    // 创建大小为newCapacity的一个新数组,将该地址赋值给elementData
    elementData = Arrays.copyOf(elementData, newCapacity);
}

add(int index,E e)

public void add(int index, E element) {
    //index范围检查
    rangeCheckForAdd(index);
    //检验是否要扩容,让增量++
    ensureCapacityInternal(size + 1);
    //这步操作其实就相当于将index后的数据向后移动
    System.arraycopy(elementData, index, elementData, index + 1,
                size - index);
    elementData[index] = element;
    size++;
}
//index范围检查
private void rangeCheckForAdd(int index) {
    //超出指定范围就抛异常
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//是否需要扩容
private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    //修改集合的次数++
    modCount++;
    //如果再调用 add(index,element) 方法之前已经扩容,那么源码跟踪到此结束
    //不会进行扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

addAll()

public boolean addAll(Collection<? extends E> c) {
    //把集合的元素存到Object类型的数组中
    Object[] a = c.toArray();
    //获取数组的长度
    int numNew = a.length;
    //检验是否要扩容,让增量++
    ensureCapacityInternal(size + numNew);
    //将a数组的元素拷贝到elementData数组中
    System.arraycopy(a, 0, elementData, size, numNew);
    //长度加上a数组的长度
    size += numNew;
    //a数组的长度若不等于0,说明添加成功
    return numNew != 0;
}

addAll(index,c)

public boolean addAll(int index, Collection<? extends E> c) {
    //校验index是否合法
    rangeCheckForAdd(index);
    //将数据转成数组
    Object[] a = c.toArray();
    //获取数据的长度
    int numNew = a.length;
    //是否需要数组扩容
    ensureCapacityInternal(size + numNew);
    //numMoved:代表要移动元素的个数
    int numMoved = size - index;
    //判断需要移动的个数是否大于0
    if (numMoved > 0)
        //使用System中的方法arraycopy进行移动
        System.arraycopy(elementData, index, elementData, index + numNew,
                        numMoved);
    //将数据源 c 中的所有数据添加到数据目的
    System.arraycopy(a, 0, elementData, index, numNew);
    //长度加上数据源的长度
    size += numNew;
    //数据源长度不为0,则添加成功
    return numNew != 0;
}
    //检验index是否合法
private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}
    }
}

删除操作(remove):

remove(int index) 删除指定下标的元素

public E remove(int index) {
    //范围校验
    rangeCheck(index);
    //增量++
    modCount++;
    //将下标为index的元素赋值给 oldValue
    E oldValue = elementData(index);
    //计算集合需要移动元素个数
    int numMoved = size - index - 1;
    //若需要移动元素个数大于0,通过arrayCopy方法进行拷贝
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                    numMoved);
    //将集合最后一个元素置为null,help GC
    elementData[--size] = null;
    //返回被删除的元素
    return oldValue;
}

remove(Object o) :删除指定元素

public boolean remove(Object o) {
    //判断要删除的元素是否为null
    if (o == null) {
        //遍历集合
        for (int index = 0; index < size; index++)
            //判断集合的元素是否为null
            if (elementData[index] == null) {
                //如果相等,调用fastRemove方法快速删除
                fastRemove(index);
                return true;
            }
    } else {
        //遍历集合
        for (int index = 0; index < size; index++)
            //用o对象的equals方法和集合每一个元素进行比较
            if (o.equals(elementData[index])) {
                //如果相等,调用fastRemove方法快速删除
                fastRemove(index);
                return true;
            }
    }
    //如果集合没有o该元素,那么就会返回false
    return false;
}
//删除操作
private void fastRemove(int index) {
    //增量++
    modCount++;
    //计算集合需要移动元素的个数
    int numMoved = size - index - 1;
    //若需要移动的个数大于0,用arrayCopy方法进行拷贝
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                    numMoved);
    //将集合最后一个元素置为null,help GC
    elementData[--size] = null;
}

覆盖操作(set):

set(int index,E e) :用 e 替换给定的下标的数据

public E set(int index, E element) {
    //index安全校验
    rangeCheck(index);
    //取出index对应的元素,且赋值给oldValue
    E oldValue = elementData(index);
    //将element直接覆盖index对应的元素
    elementData[index] = element;
    //返回原先的元素
    return oldValue;
}
//index校验
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

获取方法(get):

get(int index):获取给定下标的值(随机访问)

public E get(int index) {
    //范围校验
    rangeCheck(index);
    //通过索引取出元素
    return elementData(index);
}

清除操作(Clear):

clear():清空list集合的数据

public void clear() {
    //实际修改集合次数++
    modCount++;
    //遍历集合,将集合每一个索引对应位置上的元素都置为null,尽早让其释放
    for (int i = 0; i < size; i++){
        elementData[i] = null;
    }
    //集合长度更改为0
    size = 0;
}

包含操作(Contains):

contains(Object o):判断该集合是否包含o

public boolean contains(Object o) {
    //调用indexOf方法进行查找
    return indexOf(o) >= 0;
}

public int indexOf(Object o) {
    //如果元素是null,也进行遍历操作
    if (o == null) {
        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;
            }
        }
    }
    //不存在则返回-1
    return -1;
}

是否为空(IsEmpty):

isEmpty()

public boolean isEmpty() {
    return size == 0;
}

自定义MyArrayList

import java.util.ArrayList;
import java.util.NoSuchElementException;

class MyArrayList<E> {
    //数组
    private Object[] array;
    //数据长度
    private int size;
    //默认容量
    private static final int DEFAULT_CAPACITY = 10;
    //空数组
    private Object[] emptyArray = {};

    public MyArrayList() {
        this(0);
    }

    public MyArrayList(int initCapacity) {
        if(initCapacity > 0) {
            array = new Object[initCapacity];
        } else if(initCapacity == 0){
            array = emptyArray;
        } else {
            throw new IllegalArgumentException("Illegal Capacity" + initCapacity);
        }
    }

    //检查index是否合格
    public boolean checkIndex(int index) {
        return index >= 0 && index < size() ? true : false;

    }

    //判断是否需要扩容
    private void isextend(){
        //判断集合是否为空 只会进一次
        if(array == emptyArray) {
            //第一次扩容
            array = new Object[DEFAULT_CAPACITY];
        }

        //1.5倍扩容
        if(size == array.length) {
            Object[] newArray = new Object[array.length + (array.length >> 1)];  //1.5倍扩容
            //拷贝元素
            System.arraycopy(array,0,newArray,0,array.length);
            array = newArray;
        }
    }

    //添加
    public boolean add(E val) {
        isextend();
        //添加数据
        array[size++] = val;
        return true;
    }

    //往index添加
    public boolean add(int index,E val) {
        //是否需要扩容
        isextend();
        //将数据往后移动
        for(int i=this.size-1;i >= index ;i--) {
            array[i+1] = array[i];
        }
        //将val添加到index位置
        array[index] = val;

        size++;
        return true;
    }

    //删除
    public Object removeObj(E val) {
        int index = indexOf(val);
        if(!checkIndex(index)) {
            throw new NoSuchElementException("NoSuchElementException " + val);
        }
        Object oldVal = remove(index);
        return oldVal;
    }

    //删除index
    public Object remove(int index) {
        if(!checkIndex(index)) {
            throw new IllegalArgumentException("Illegal index " + index);
        }

        Object oldVal = array[index];
        //移动可以使用System.arraycopy()
//        System.arraycopy(array,index,array,index+1,size-index);
        //将index后面的值往前移
        for (int i = index; i < size-1; i++) {
            array[i] = array[i+1];
        }

        array[--size] = null;  //help GC
        return oldVal;
    }

    //获取index位置的值 get
    public Object get(int index) {
        if(!checkIndex(index)) {
            throw new IllegalArgumentException("Illegal index " + index);
        }
        return array[index];
    }

    //clear
    public void clear(){
        for (int i = 0; i < size; i++) {
            array[i] = null;
        }
        size = 0;
    }

    //是否包含该元素
    public boolean contains(E val){
        return indexOf(val) != -1;
    }

    //获取给定元素的下标 indexOf()
    public int indexOf(E val) {
        if(val == null) {
            for (int i = 0; i < size(); i++) {
                if(array[i] == null) {
                    return i;
                }
            }
        } else {
            for (int i = 0; i < size(); i++) {
                if(val.equals(array[i])) {
                    return i;
                }
            }
        }
        return -1;
    }

    //获取size
    public int size(){
        return size;
    }

    //判断是否为空
    private boolean isEmpty(){
        return size == 0;
    }

    //替换指定位置的元素
    public Object set(int index,E val) {
        if(!checkIndex(index)){
            throw new IllegalArgumentException("Illegal Index : "+index);
        }
        Object oldVal = array[index];
        array[index] = val;
        return oldVal;
    }

    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < size; i++) {
            sb.append(array[i]);
            if(i+1 != size) {
                sb.append(", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

public class ArrayListTest {
    
    public static void main(String[] args) {
        MyArrayList<Integer> list = new MyArrayList<>();

        //添加方法测试
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(null);
        list.add(5);
        list.add(6);
        System.out.println("添加元素后: "+list);

        //删除方法测试
        list.remove(3);
        System.out.println("删除index=3的元素: "+list);

        //给index位置添加元素
        list.add(0,0);
        System.out.println("给0号位置添加元素0: "+list);

        //删除元素
        list.removeObj(1);
        System.out.println("删除元素值为1: "+list);

        boolean contains = list.contains(6);
        System.out.println("判断是否有元素6: "+contains);

        //访问index位置的值
        Object o = list.get(1);
        System.out.println("index=1位置的值为: "+o);

        list.set(0,10);
        System.out.println("设置0号位置的值为10: "+ list);

        //clear
        list.clear();
        System.out.println("clear: "+list);
    }
}