ArrayList源码解析--基于jdk1.8

最新推荐文章于 2022-04-22 15:10:30 发布

JAVA真的太难了

最新推荐文章于 2022-04-22 15:10:30 发布

阅读量230

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_41202539/article/details/105944367

版权

文章目录

结构

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

ArrayList类继承自AbstactList类，并实现了RandomAccess、Cloneable、java.io.Serializable接口，表明其支持随机访问，克隆和序列化。

类的属性

// 序列化id
private static final long serialVersionUID = 8683452581122892189L;

/**
* Default initial capacity. 默认的初始化容量
*/
private static final int DEFAULT_CAPACITY = 10;

/**
* Shared empty array instance used for empty instances.
* 指定该ArrayList容量为0时，返回该空数组。
*/
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
* 当调用无参构造方法，返回的是该数组。刚创建一个ArrayList 时，其内数据量为0。
* 它与EMPTY_ELEMENTDATA的区别就是：该数组是默认返回的，而EMPTY_ELEMENTDATA是在用户指定容量为0时返回。
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
* 保存添加到ArrayList中的元素。 
* ArrayList的容量就是该数组的长度。 
* 该值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时，当第一次添加元素进入ArrayList中时，数组将扩容值DEFAULT_CAPACITY。 
* 被标记为transient，在对象被序列化的时候不会被序列化。
*/
transient Object[] elementData; // non-private to simplify nested class access

/**
* ArrayList的实际大小（数组包含的元素个数/实际数据的数量）默认为0
* @serial
*/
private int size;
  
/**
* 分派给arrays的最大容量
* 为什么要减去8呢？
* 因为某些VM会在数组中保留一些头字，尝试分配这个最大存储容量，可能会导致array容量大于VM的limit，最终导致OutOfMemoryError。
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//备注：MAX.VALUE为0x7fffffff，转换成十进制就是2147483647，也就是数组的最大长度是2147483639；

构造函数

/**
 * 有参构造器，参数为0时返回 EMPTY_ELEMENTDATA 数组
 *  */
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);
        }
    }

    /**
     * 无参构造器，返回 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 默认数组
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

常用方法

add方法

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 扩容操作判断
        elementData[size++] = e;
        return true;
    }

    public void add(int index, E element) {
        rangeCheckForAdd(index);//检查index参数是否合法

        ensureCapacityInternal(size + 1);  //扩容操作判断
        //利用System.arraycopy实现将elementData数组index后的元素全部后一个位置。
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

public static void arraycopy(Object src, int srcPos, Object dest, int
destPos, int length)
代码解释: 　　
Object src : 原数组
int srcPos : 从元数据的起始位置开始　　
Object dest : 目标数组　　
int destPos : 目标数组的开始起始位置　　
int length : 要copy的数组的长度

contains方法

public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

public int indexOf(Object o) {
        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;
        }
        return -1;
    }

调用indexOf方法，如果放回结果大于0，即存在。

get方法

public E get(int index) {
        rangeCheck(index);//判断参数是否合法

        return elementData(index);
    }

E elementData(int index) {
        return (E) elementData[index];
    }

由于ArrayList底层为Object数组，支持随机访问，所以可以直接访问元素，只需要加上强制类型转换即可。

remove方法

传入int

public E remove(int index) {
        rangeCheck(index);//检查参数

        modCount++;//修改次数加一
        E oldValue = elementData(index);

        int numMoved = size - index - 1;//index后面的元素个数
        //如果index不是最后一个，利用System.arraycopy删除。
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; //size-1

        return oldValue;
    }

传入object

public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                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
    }

底层操作和传入int类型一致。

clear方法

public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

set方法

public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

toArray方法

public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

扩容机制！！！！

扩容算法是基于方法grow()的，ArrayList的几个构造参数，决定了在初始状态下，容器的大小要么为0要么为自己设定的某个值。那么具体的扩容，就是在add()等方法进行的时候进行一次判定——如果有数组溢出的风险，那么就进行扩容。

扩容算法是基于方法grow()的，ArrayList的几个构造参数，决定了在初始状态下，容器的大小要么为0要么为自己设定的某个值。那么具体的扩容，就是在add()等方法进行的时候进行一次判定——如果有数组溢出的风险，那么就进行扩容。
扩容的时候先判定数组大小。数组是空或者小于10，那么在扩容的时候将数组直接分配大小到10。之后每次扩容，是变成原数组长度的1.5倍。但是有一个最大值——2^31-9，如果大于这个数会看当前数组大小到底是多少，如果小于该值，那么直接扩容到，反之，则扩容到最大值。

在调用add时触发扩容机制

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

ensureCapacityInternal

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

调用ensureExplicitCapacity

calculateCapacity

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

ensureExplicitCapacity

private void ensureExplicitCapacity(int minCapacity) {
        modCount++; //对List修改的次数，为父类AbstractList的属性

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

当最小最小容量大于elementData的长度时进行grow扩容操作。

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        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);
    }

扩容时，新容量为原容量的1.5倍。若新容量小于最小容量（即add后的有效元素个数）则把minCapacity赋值给容量。假如新容量大于MAX_ARRAY_SIZE 2^31-8,则调用hugeCapacity。最后用Arrays.copyOf进行数组扩容。

private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

总结

一、elementData[] 数组为object类数组，用于存放ArrayList中的元素，且数组长度不随ArrayList元素的个数增加而随之增加，要根据扩容算法，进行扩容。
二、size为ArrayList中存放的元素个数。
三、扩容操作为add操作触发。
四、构造函数：

无参时，默认elementData数组为DEFAULTCAPACITY_EMPTY_ELEMENTDATA空数组；
有参数时，若为0，则elementData数组为EMPTY_ELEMENTDATA空数组；
若传入Collection时，将collection对象转换成数组，然后将数组的地址的赋给elementData。如果数组的实际大小等于0（c中没有元素），将空数组EMPTY_ELEMENTDATA赋值给elementData。如果size的值大于0，则执行Arrays.copy方法，把collection对象的内容（可以理解为深拷贝）copy到elementData中。

五、扩容机制：

当elementData为空时，第一次添加元素，直接将数据扩容为10
若添加后元素个数（即size+1，minCapacity）大于当前elementData的长度，进行grow扩容操作。
grow规定新容量为原容量的1.5倍。若新容量小于size+1，则令新容量等于minCapacity，若新容量大于MAX_ARRAY_SIZE （即2^31-8）：此时若minCapacity大于MAX_ARRAY_SIZE 则新容量为Integer.MAX_VALUE（即2^31）,否则为MAX_ARRAY_SIZE 。

参考链接

https://blog.csdn.net/iwts_24/article/details/90211266
https://blog.csdn.net/u010250240/article/details/89762912

JAVA真的太难了

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
ArrayList源码解析--基于jdk1.8

类的属性// 序列化idprivate static final long serialVersionUID = 8683452581122892189L;/*** Default initial capacity. 默认的初始化容量*/private static final int DEFAULT_CAPACITY = 10;/*** Shared empty array ...
复制链接

扫一扫