JAVA源码阅读之ArrayList基于JDK1.8

最新推荐文章于 2021-10-03 20:55:18 发布

乙-second

最新推荐文章于 2021-10-03 20:55:18 发布

阅读量162

点赞数

分类专栏： Java学习记录

本文链接：https://blog.csdn.net/qq_33617079/article/details/81207324

版权

Java学习记录专栏收录该内容

4 篇文章 0 订阅

订阅专栏

在Java中，List列表是我们经常需要使用的一种数据结构，List作为一个接口，定义了集合列表的基本行为，在java api的具体实现有ArrayList以及LinkedList，这两个实现也是经常需要用到的。本篇主要从源码看下ArrayList各个常用方法的具体实现

1.类继承实现关系

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

可以看到，ArrayList在类的结构上继承了AbstractList<E>类，实现上实现了List接口，

RandomAccess接口提供随机快速访问的能力，起标记作用，随机访问时会根据有无实现此接口选择不同的算法；

Cloneable克隆接口，对象调用clone()方法时会在堆中新建一个与之前对象状态一样的对象，

Serializable序列化接口

2.类的一些重要的域

//默认的缺省容量 可以定义初始数组的长度
private static final int DEFAULT_CAPACITY = 10;

//默认的空数组 构造函数会用到
private static final Object[] EMPTY_ELEMENTDATA = {};

//也是一个空数组，构造函数以及扩容时会用到
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

//被操作的数组 数据的存放数组
transient Object[] elementData;

//维护当前集合的长度大小（此处的size并不一定等于elementData数组的长度，在add和remove方法中可以看到）
//size大小总是小于或等于elementData.length
private int size;

从ArrayList的这些域中可以看到，ArrayList数据结构的底层是通过数组来实现的，数组是一种线性的数据结构，具有查找快，插入/删除的特点

3.构造方法

ArrayList一共有3个构造函数,接下来分别来看下3个构造函数的具体内容

ArrayList(int initialCapacity)

 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);
    }
 }

这个构造函数会传入一个数组初始化大小的参数，如果大于0的话，则新创建一个大小为initialCapacity的数组，并将引用赋值给 elementData，如果等于0的话，则将域中的空数组EMPTY_ELEMENTDATA引用赋值给elementData。

ArrayList()

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

此构造函数是一般用到的空构造函数，里面内容很简单，将DEFAULTCAPACITY_EMPTY_ELEMENTDATA引用赋值给 elementData。

ArrayList(Collection<? extends E> c)

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;
    }
}

和ArrayList(int initialCapacity)的实现差不多，会判断一下大小和类型,类型一致且大小不为0时会使用Arrays.copyOf方法复制数组所以这时初始化不为空,

前面了解了ArrayList的类的结构以及3个构造函数，还有一些比较重要的域(变量),接下来就看下ArrayList在实际比较常用的几个方法的源码吧

4.添加

add(E e)

public boolean add(E e) {
    //判断数组长度是否足够新增新的元素进去
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //数组下标赋值 并将列表size的大小加1
    elementData[size++] = e;
    return true;
}

以下几个方法是判断当前数组长度是否足够添加新的元素进去

private void ensureCapacityInternal(int minCapacity) {
    //如果是刚初始化的空数组，则取值缺省容量因子和参数的最大值表示新的数组长度
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //判断当前数组长度是否足够 新增后的长度
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    //当前数组长度不足 则对当前的数组进行长度扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

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:
    //复制长度为newCapacity的数组赋值给elementData
    elementData = Arrays.copyOf(elementData, newCapacity);
}

总结

新添加一个元素到ArrayList中时，会将表示新增后的列表大小size+1作为参数调用ensureCapacityInternal方法，在 ensureCapacityInternal方法中会判断当前数组是否为空数组，取得列表需要到达的大小，调用ensureExplicitCapacity判断当前的elementData数组的大小是否足够放下新的元素，如果不够的话，就要对elementData的数组大小进行动态扩容；也就是说 add 方法先判断当前数组大小是否足够容下新增元素，不够的话就动态扩容当前数组，最后下标赋值,size自增1。

5.移除元素

remove(int index),remove(Object o)

首先来看下remove(int index)方法

 public E remove(int index) {
    //下面的方法检测下标是否越限
    rangeCheck(index);
    modCount++;
    E oldValue = elementData(index);
    //判断是否移除的最后一项，如果不是，则将移除项前后拼接成新的数组
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    //将最后一项置为空，size自减1,数组长度并没有发生变化
    elementData[--size] = null; // clear to let GC do its work
    return oldValue;
 }

接下来看下remove(Object o)方法

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;
}

先判断移除的对象是否为空，为空则从数组中遍历找到第一个为空的下标，通过fastRemove方法移除该下标的元素

不为空则遍历数组找到第一个相等的下标，也是通过fastRemove移除

fastRemove方法的代码和remove(int index)中的一些代码块一样

6.获取元素

public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

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

此方法较为简单，先判断下标是否越限，再通过数组下标取出元素强转返回

7.设置元素

public E set(int index, E element) {
    rangeCheck(index);
    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

先判断下标是否越限，将数组对应的下标引用重新赋值到新对象引用上

8.清除

public void clear() {
    modCount++;

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

    size = 0;
}

遍历数组，将每一个下标的引用置为null，size大小重置为0，数组未发生变化

9.遍历

在集合中，一般遍历都是通过 Iterator 类来进行的，ArrayList也实现了该类以及返回该类的方法

public Iterator<E> iterator() {
    return new Itr();
}

Itr是在ArrayList中定义的一个实现 Iterator接口的一个内部类，如下

 private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

可以看到在 Itr 实现的next()方法，remove方法，最终c操作的还是ArrayList的elementData数组以及remove方法，比较简单

10.总结

以上从源码看到ArrayList的类结构，构造方法以及一些常规的方法，还有其他方法没有贴上来，大体上都差不多，像addAll,removeAll和all，remove方法比较类似，所以就不贴上来了。ArrayList是通过数组来实现的，从Add方法可以看到当数组长度不够时，会对当前数组进行扩容，增量大小一般情况下为之前长度的一半，间接促使数组拥有动态的变化，可以使我们无所顾虑的像列表增加新的元素，占用内存只增不少，从remove，clear方法也可以看到并不会对数组的长度发生变化，数组占用的空间还是那么大。

所以ArrayList的特点是占用内存大，查找快，插入和删除慢

乙-second

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA源码阅读之ArrayList基于JDK1.8

在Java中，List列表是我们经常需要使用的一种数据结构，List作为一个接口，定义了集合列表的基本行为，在java api的具体实现有ArrayList以及LinkedList，这两个实现也是经常需要用到的。本篇主要从源码看下ArrayList各个常用方法的具体实现目录1.类继承实现关系2.类的一些重要的域3.构造方法4.添加5.移除元素6.获取元素7.设置元素...
复制链接

扫一扫

专栏目录