ArrayList-源码

ML李嘉图

概述

(1)ArrayList 是一种变长的集合类,基于定长数组实现。

(2)ArrayList 允许空值和重复元素,添加元素时,会扩容机制生成一个更大的数组。

(3)可以保证在 O(1) 复杂度下完成随机查找操作。

(4)ArrayList 是非线程安全类。

为追求效率,ArrayList没有实现同步(synchronized),如果需要多个线程并发访问,用户可以手动同步,也可使用Vector替代。

类的属性

/**
 * 默认初始容量
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * 共享的空数组实例,用于空实例
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 *ArrayList 实际数据存储的一个数组
 *存储ArrayList的元素的数组缓冲区。 ArrayList的容量是此数组缓冲区的长度。
 *添加第一个元素时,任何具有elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList都将扩展为DEFAULT_CAPACITY。
 
 
 
 Object[]数组,也就是说该数组可以放任何对象(所有对象都继承自父类Object)
 */
transient Object[] elementData;

/**
 * 共享的空数组实例,用于默认大小的空实例
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * elementData 的大小,size是逻辑长度,并不是数组长度。
 */
private int size;

//很有意思,下面介绍
protected transient int modCount = 0;

static修饰的变量,常驻于方法区,我们不需要new,JVM会提前给我们初始化好,这个特性在实际开发过程中,经常拿来做缓存。

ArrayList new的时候考虑了缓存,为了避免我们反复的创建无用数组,所有新new出来的ArrayList底层数组都指向缓存在方法区里的Object[]数组。

构造方法

    //参数为初始化容量
public ArrayList(int initialCapacity) {
    //判断容量的合法性
    if (initialCapacity > 0) {
        //elementData才是实际存放元素的数组
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        //如果传递的长度为0,就是直接使用自己已经定义的成员变量(一个空数组)
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}


    
    //无参构造,使用默认的size为10的空数组,在构造方法中没有对数组长度进行设置,会在后续调用add方法的时候进行扩容
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}


    
    //将一个参数为Collection的集合转变为ArrayList(实际上就是将集合中的元素换为了数组的形式)。
//传入的集合为null会抛出空指针异常(调用c.toArray()方法的时候)
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        //c.toArray()可能不会正确地返回一个 Object[]数组,那么使用Arrays.copyOf()方法
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        //如果集合转换为数组之后数组长度为0,就直接使用自己的空成员变量初始化elementData
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

图解析:例如 List<Person> list2 = new ArrayList<>(); 出来的 list2 为空,指向一个 static final Object[] ,

当添加元素后,elementData 指向 elementData[10](DEFAULT_CAPACITY = 10),size 是逻辑长度,加一。

add,grow以及工具类底层分析

    public boolean add(E e) {
        //因为要添加元素,所以添加之后可能导致容量不够,所以需要在添加之前进行判断(扩容)
        ensureCapacityInternal(size + 1);  
        // Increments modCount!!待会会介绍到fast-fail!!
        //但是这个扩容的方法里面调用了。add()方法就不用调用了。其实是调用过了的,modCount 已经加了1。
        
        
        //值e放到相应的elementData[]下标的数组里面
        elementData[size++] = e;
        return true;
    }



     private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }


    //如果底层数组就是默认的缓存数组,取两个参数的大的一个值继续往下调用

    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        //这里就是判断elementData数组是不是为空数组
        //(使用的无参构造的时候,elementData=DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        //如果是,那么比较size+1(第一次调用add的时候size+1=1)和DEFAULT_CAPACITY,
        //那么显然容量为10
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }


    private void ensureExplicitCapacity(int minCapacity) {
        //记录修改次数
        modCount++;
        //溢出
        //如果传过来的值大于底层数组的长度,继续grow方法。
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }


   private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    private void grow(int minCapacity) {
        // oldCapacity为旧数组的容量
        int oldCapacity = elementData.length;
        // newCapacity为新数组的容量(oldCap+oldCap/2:即更新为旧容量的1.5倍)
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 检查新容量的大小是否小于最小需要容量,如果小于那旧将最小容量最为数组的新容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //如果新容量大于MAX_ARRAY_SIZE,使用hugeCapacity比较二者
        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);
}



    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    
    @Native public static final int   MAX_VALUE = 0x7fffffff;

    
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
        //对minCapacity和MAX_ARRAY_SIZE进行比较
        //若minCapacity大,将Integer.MAX_VALUE作为新数组的大小
        //若MAX_ARRAY_SIZE大,将MAX_ARRAY_SIZE作为新数组的大小
        //MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}






    //工具类
    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;
    }


    //System.arraycopy()方法,native方法,所以直接只用这个方法会获得很高的性能
    //这个也是具体的扩容的具体底层实现

    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);
//src:源数组   
//srcPos:从源数组的srcPos位置处开始移动
//dest:目标数组
//desPos:源数组的srcPos位置处开始移动的元素,这些元素从目标数组的desPos处开始填充
//length:移动源数组的长度

扩容:newCapacity为新数组的容量(oldCap+oldCap/2:即更新为旧容量的1.5倍

remove方法分析

1、remove(int index) 按照下标删除

public E remove(int index) {
    rangeCheck(index); //校验下标是否合法(如果index>size,旧抛出IndexOutOfBoundsException异常)
    modCount++;//修改list结构,就需要更新这个值
    E oldValue = elementData(index); //直接在数组中查找这个值

    int numMoved = size - index - 1;//这里计算所需要移动的数目
    //如果这个值大于0 说明后续有元素需要左移(size=index+1)
    //如果是0说明被移除的对象就是最后一位元素(不需要移动别的元素)
    if (numMoved > 0)
        //索引index只有的所有元素左移一位  覆盖掉index位置上的元素
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    //移动之后,原数组中size位置null
    elementData[--size] = null; // clear to let GC do its work
    //返回旧值
    return oldValue;
}

2、remove(Object o) 按照元素删除,会删除和参数匹配的第一个元素

public boolean remove(Object o) {
    //如果元素是null 遍历数组移除第一个null
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                //遍历找到第一个null元素的下标 调用下标移除元素的方法
                fastRemove(index);
                return true;
            }
    } else {
        //找到元素对应的下标 调用下标移除元素的方法
        for (int index = 0; index < size; index++)
               //要用equals
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}


//按照下标移除元素(通过数组元素的位置移动来达到删除的效果)
private void fastRemove(int index) {
  modCount++;
  int numMoved = size - index - 1;
  if (numMoved > 0)
    System.arraycopy(elementData, index+1, elementData, index,
                     numMoved);
  elementData[--size] = null; // clear to let GC do its work
}

fail-fast

在系统设计中,快速失效系统一种可以立即报告任何可能表明故障的情况的系统。

快速失效系统通常设计用于停止正常操作,而不是试图继续可能存在缺陷的过程。

这种设计通常会在操作中的多个点检查系统的状态,因此可以及早检测到任何故障。

快速失败模块的职责是检测错误,然后让系统的下一个最高级别处理错误。

在Java集合类中很多地方都用到了该机制进行设计,一旦使用不当,触发fail-fast机制设计的代码,就会发生非预期情况。

我们通常说的Java中的fail-fast机制,默认指的是Java集合的一种错误检测机制

当多个线程对部分集合进行结构上的改变的操作时,有可能会触发该机制时,之后就会抛出并发修改异常ConcurrentModificationException.

然如果不在多线程环境下,如果在foreach遍历的时候使用add/remove方法,也可能会抛出该异常。

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  
        // Increments modCount!!待会会介绍到fast-fail!!
        //但是这个扩容的方法里面调用了。add()方法就不用调用了。其实是调用过了的,modCount 已经加了1。
        
        
        
        elementData[size++] = e;
        return true;
    }

Arraylist与Vector的区别

用得比较少了。

public class Vector<E>
    extends AbstractList<E>
    //实现List接口
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    //底层数组实现
    protected Object[] elementData;

    
    protected int elementCount;

   
    protected int capacityIncrement;

Vector源码分析

       //声明了同步得关键字
    public synchronized boolean add(E e) {
        modCount++;
        //检查是否扩容
        ensureCapacityHelper(elementCount + 1);
        //赋值
        elementData[elementCount++] = e;
        return true;
    }

无一例外,只要是关键性的操作,方法前面都加了synchronized关键字,来保证线程的安全性。

不同点:扩容后是旧容量的俩倍。

参考链接

https://juejin.cn/post/684490...

https://zhuanlan.zhihu.com/p/...

https://juejin.cn/post/698127...

阅读 254
4 声望
0 粉丝
0 条评论
你知道吗?

4 声望
0 粉丝
宣传栏