《咱们一块儿学集合》-ArrayList

时间  2021-02-21
标签 java 面试 segmentfault 数组 安全 微信 数据结构 app dom jvm 栏目 Java 繁體版
原文   原文链接
微信关注【面试情报局】咱们一块儿干翻面试官。

1.前言

今天咱们要研究的集合是ArrayList，在咱们学习ArrayList以前，咱们先看看面试官是如何利用ArrayList的相关知识点来吊打咱们得。java

  1. ArrayList的底层结构是什么？
  2. ArrayList的初始化容量是多少？
  3. ArrayList的容量会变吗?是怎么变化滴？
  4. ArrayList是线程安全的吗？
  5. ArrayList和LinkedList有什么区别？

看了这些面试题，是否是心里以为:面试

image

言归正传，下面咱们就经过ArrayList源码学习来解决解决上述问题。segmentfault

2.概述

ArrayList是基于数组，支持自动扩容的一种数据结构。相比数组来讲，由于他支持自动扩容，而且内部实现了不少操做数组的方法，因此成为咱们平常开发中最经常使用的集合类。其内部结构以下：数组

image

3.类图

image

  • AbstractList 抽象类，提供了List接口的相关实现和迭代逻辑的实现，不过对ArrayList意义不大，由于ArrayList大量重写了AbstractList的实现
  • List 接口，定义了数组的增删改查迭代遍历等相关操做。
  • Cloneable 接口，支持ArrayList克隆
  • Serializabel 接口，支持ArrayList序列化与反序列化
  • RandomAccess 接口，支持ArrayList快速访问

4.属性

先让咱们看看ArrayList的源码：安全

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // 默认初始容量。
    private static final int DEFAULT_CAPACITY = 10;

    // 用于空实例的共享空数组(建立空实例时使用)
    private static final Object[] EMPTY_ELEMENTDATA = {};

    // 用于默认大小的空实例的共享空数组实例。
    // 咱们将其与EMPTY_ELEMENTDATA区分开来，以便知道添加第一个元素时要膨胀多少。
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    // 存储数组列表元素的数组缓冲区。arrayList的容量就是这个数组缓冲区的长度。
    // 任何空的ArrayList 将被扩展到10当(第一次添加元素时)
    // 注意是经过transient修饰
    transient Object[] elementData; // non-private to simplify nested class access

    // 数组列表的大小(它包含的元素数量)
    private int size;

    /* 要分配的数组的最大大小
     * 尝试分配更大的数组可能会致使OutOfMemoryError:请求的数组大小超过VM限制*/
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    // 该属性是经过继承 AbstractList 得来,列表修改的次数(版本号)
    protected transient int modCount = 0;
}

经过源码咱们能够知道到：微信

  • DEFAULT_CAPACITY 表示ArrayList的初始容量（采用无参构造时第一次添加元素扩容的容量，后面会介绍），默认是10。
  • elementData 表示ArrayList实际储存数据的数组，是一个Object[]。
  • size 表示该ArrayList的大小(就是elementData包含的元素个数)。
  • MAX_ARRAY_SIZE 表示ArrayList能分配的最大容量 Integer.MAX_VALUE - 8
  • modCount 表示该ArrayList修改的次数，在迭代时能够判断ArrayList是否被修改。

看到这里，咱们就能够很轻松回答上面的1和2两个问题。数据结构

  1. ArrayList的底层结构是什么？
  2. ArrayList的初始化容量是多少？

ArrayList底层实现就是一个数组，其初始容量是10。app

image

5.经常使用方法

5-1.构造函数

首先仍是让咱们看看源码，由于源码最有说服力。

dom

// 使用指定的初始容量构造一个空列表。
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA; // 若是为0使用默认空数组
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
    }
}

/*Constructs an empty list with an initial capacity of ten.
* 构造一个初始容量为10的空列表。(在第一次扩容时容量才为10，如今仍是null)*/
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

// 构造一个包含指定集合的元素的列表，按照集合的迭代器返回它们的顺序。
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray(); // 将集合转变为数组
    // 赋值 size 并判非 0
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652) 这是一个bug在java9已经被解决
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

经过查看源码咱们能够发现：jvm

  • ArrayList 有三个构造函数：指定初始化大小构造，无参构造，指定初始化数据构造
  • ArrayList的无参构造，其实默认是空数组，咱们上面说的初始化容量默认为10，是当咱们用无参构造函数后，第一次向ArrayList添加元素时扩容的默认大小。

5-2.增长

ArrayList添加元素的方法有四个：一个是在末尾添加，一个是指定索引添加，另两个是在末尾添加集合和在指导索引位置添加集合

// 将指定的元素添加到列表的末尾。
public boolean add(E e) {
    // 确保容量足够
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

// 在列表指定的位置插入指定的元素。
// 将当前位于该位置的元素(若是有的话)和随后的元素向右移动(下标加1)。
public void add(int index, E element) {
    // 确保索引合法
    rangeCheckForAdd(index);
    // 确保容量
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 移动元素 （原始数组,起始位置，目标数组，起始位置，拷贝大小）
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++; // 大小加 1
}

private void ensureCapacityInternal(int minCapacity) {
    // 判断是否是经过无参构造建立的
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 这才是第一次添加元素是默认扩容到10
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

// 预扩容
private void ensureExplicitCapacity(int minCapacity) {
    modCount++; // 修改版本号
    // overflow-conscious code 
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

// 增长容量，以确保至少能够保存由最小容量(minCapacity)参数指定的元素数量。
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // 1.5倍扩容
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0) // 扩容后不知足指望大小则以指望大小做为容量
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0) // 分配jvm的最大容量，防溢出
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    // 扩容
    elementData = Arrays.copyOf(elementData, newCapacity);
}

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

// 将指定集合中的全部元素追加到此列表的末尾。按照指定集合的迭代器返回它们的顺序。
public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray(); // 集合转数组
    int numNew = a.length;    // 获取要添加的长度
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew); // 经过元素拷贝来追加元素
    size += numNew;
    return numNew != 0;
}

// 将指定集合中的全部元素插入到此列表中，从指定位置开始。
// 新元素将按照指定集合的迭代器返回的顺序出如今列表中。
public boolean addAll(int index, Collection<? extends E> c) {
    rangeCheckForAdd(index); // 检查索引是否合法

    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount

    int numMoved = size - index;
    if (numMoved > 0) // 腾出空位
        System.arraycopy(elementData, index, elementData, index + numNew,numMoved);
    // 将a拷贝到elementData
    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}

image

经过源码咱们知道ArrayList添加元素大体流程以下：

image

经过源码咱们须要注意：

  • 扩容是原容量+原容量大小一半，也就是说是按照1.5倍扩容:oldCapacity + (oldCapacity >> 1),但最后的容量并不必定是按照这个规则计算获得的大小，由于他还有两个if判断。
  • ArrayList中数组最大只能分配Integer.MAX_VALUE,在大就会致使OutOfMemoryError。
  • ArrayList扩容时有许多溢出判断操做，这很是值得借鉴。
  • ArrayList扩容底层调用的是System.arraycopy(Object src,int srcPos,Object dest, int destPos,int length)方法,每一个参数对应为(原始数组,起始位置，目标数组，起始位置，拷贝大小)

看到这里咱们能够回答第3个问题：

ArrayList的容量会变吗?是怎么变化滴？

数组容量会改变，改变的规则是按照原数组1.5倍进行扩容，但最终容量不必定是经过该规则计算获得的值，由于后面有两个if判断：1.是否知足指望容量；2.是否超出jvm分配的最大容量

image

5-3.删除

ArrayList删除元素的方法有四个：删除指定索引位置的元素，删除指定元素，删除指定集合元素和经过过滤器删除

// 删除列表中指定位置的元素。将全部后续元素向左移动(从它们的下标减去1)。
public E remove(int index) {
    // 确保index合法
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index); // 获取老元素

    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

    return oldValue;
}

// 从列表中删除指定元素的第一个匹配项，若是它存在的话并返回 true。
public boolean remove(Object o) {
    if (o == null) { // 空值单独删除,由于add时也没有对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])) { // 经过equals比较，若是是自定义对象元素，必定要重写它
                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
}

// 今后列表中删除指定集合中包含的全部元素。
// 若是此列表包含空元素，而指定的集合不容许空元素则会抛出NullPointerException
public boolean removeAll(Collection<?> c) {
    // 判断是否为null
    Objects.requireNonNull(c);
    return batchRemove(c, false);
}

// 经过不一样complement来操做列表
private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    boolean modified = false;
    try {
        for (; r < size; r++) // complement决定操做行为
            if (c.contains(elementData[r]) == complement) 
                elementData[w++] = elementData[r];
    } finally {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        if (r != size) {
            System.arraycopy(elementData, r,elementData, w,size - r);
            w += size - r; 
        }
        if (w != size) { // 将删除的元素赋null
            // clear to let GC do its work
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

@Override
public boolean removeIf(Predicate<? super E> filter) {
    Objects.requireNonNull(filter);
    // figure out which elements are to be removed 找出要删除的元素
    // any exception thrown from the filter predicate at this stage
    // will leave the collection unmodified
    int removeCount = 0;
    final BitSet removeSet = new BitSet(size); // 记录要删除元素的集合
    final int expectedModCount = modCount; // 记录版本号
    final int size = this.size;
    for (int i=0; modCount == expectedModCount && i < size; i++) {
        @SuppressWarnings("unchecked")
        final E element = (E) elementData[i];
        if (filter.test(element)) { // 记录要删除的元素index
            removeSet.set(i);
            removeCount++;
        }
    }
    if (modCount != expectedModCount) { // 若是版本号不一致，抛出异常
        throw new ConcurrentModificationException();
    }

    // shift surviving elements left over the spaces left by removed elements
    final boolean anyToRemove = removeCount > 0;
    if (anyToRemove) {
        final int newSize = size - removeCount;
        // 遍历并剔除要删除的元素
        for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
            i = removeSet.nextClearBit(i);
            elementData[j] = elementData[i];
        }
        for (int k=newSize; k < size; k++) {
            elementData[k] = null;  // Let gc do its work
        }
        this.size = newSize;
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }
    return anyToRemove;
}

经过源码咱们能够知道：

  • ArrayList删除元素是经过System.arraycopy移动数组覆盖元素来实现的
  • ArrayList添加元素时没有校验null值，因此删除null值时是特殊处理的
  • ArrayList经过对象删除时判断相等是经过equals判断，因此咱们在储存自定义对象是要注意对equals进行重写

经过源码咱们能够看出在使用ArrayList时咱们要尽可能避免大量的随机删除，由于删除元素会致使元素拷贝（尤为是大元素），这是很是消耗性能的一件事；就算咱们经过removeAll()来删除也不是特别好，由于它也要经过c.contains()去查找元素，不一样的集合有不一样的实现方式因此查找的性能也不一样。

5-4.修改

ArrayList的修改比较简单，是经过指定索引修改

// 将列表中指定位置的元素替换为指定的元素。
public E set(int index, E element) {
    rangeCheck(index);
    E oldValue = elementData(index);
    elementData[index] = element;
    // 返回被替换的元素
    return oldValue;
}

如今咱们在看看第4问

ArrayList是线程安全的吗？

经过源码的阅读，咱们能够很轻松的回答这个问题。他是不安全的，由于他既没有在属性elementData加validate，也没有在方法上加synchronized。并且在ArrayList的类注释上明确指出他是线程不安全的，要使用线程安全的话可使用Collections.synchronizedList，或者Vector。

/* <p><strong>Note that this implementation is not synchronized.</strong>
 * If multiple threads access an <tt>ArrayList</tt> instance concurrently,
 * and at least one of the threads modifies the list structurally, it
 * <i>must</i> be synchronized externally.  (A structural modification is
 * any operation that adds or deletes one or more elements, or explicitly
 * resizes the backing array; merely setting the value of an element is not
 * a structural modification.)  This is typically accomplished by
 * synchronizing on some object that naturally encapsulates the list.
 ***************************************************************************
 * 注意，这个实现是不一样步。若是多个线程同时访问ArrayList实例，且至少有一个线程在结构上修改列表，
 * 它必须外部同步。(一个结构修改：添加或删除一个或多个元素的任何操做，或者是明确的改变数组大小，
 * 仅仅设置元素的值不是结构修改) 这一般是经过在天然封装列表的对象上同步来实现的。
 
 * If no such object exists, the list should be "wrapped" using the
 * {@link Collections#synchronizedList Collections.synchronizedList}
 * method.  This is best done at creation time, to prevent accidental
 * unsynchronized access to the list:<pre>
 *   List list = Collections.synchronizedList(new ArrayList(...));</pre>
 ***************************************************************************
 * 若是不存在这样的对象，列表应该使用方法“包装”(Collections.synchronizedList)。
 * 这最好在建立时进行，以防止意外对列表的非同步访问*/

至于第5个问题，咱们将在学习LinkedList时在来对比讲解。

6.总结

经过上面的学习，咱们已经较为深入的理解了ArrayList的底层实现，固然若是要很是深入的理解ArrayList确定须要本身亲自调试ArrayList的源码；做为面试和日常工做，了解到这里也差很少了。

ArrayList本质就是一个能够自动扩容的数组包装类，他经过无参构造函数初始化并第一次添加元素的扩容大小默认是10，日后每次自动扩容的大小是原数组容量的1.5倍oldCapacity + (oldCapacity >> 1)，在使用ArrayList时尽可能肯定初始化容量的大小，这样能够避免频繁扩容；也要尽可能避免随机插入和删除操做，这样会引发元素移动，消耗资源(尤为是对移动大元素来讲)。

最后咱们在看看ArrayList的一些方法，没有必要全记住由于我也记不住，只要有个大概印象就行了，在咱们要用的时候再去查找。

  • trimToSize() 调整列表容量为列表的当前大小
  • ensureCapacity(int minCapacity) 确保列表容量
  • size() 获取列表元素个数
  • contains(Object o) 判断是否包含某个对象
  • indexOf(Obejct o) 从前日后查找指定对象
  • lastIndexOf(Obejct o) 从后往前查找指定对象
  • clone() 克隆列表
  • toArray() 转换为数组
  • toArray(T[] a) 转换为指定类型数组
  • get(int index) 获取指定索引元素
  • set(int index,E element) 指定索引位置修改
  • add(E o) 向列表末尾添加元素
  • add(int index,E elemet) 指定位置插入元素
  • remove(int index) 移除指定索引
  • remove(Object o) 移除指定元素
  • clear() 状况列表
  • addAll(Collection<? extends E> c) 在列表末尾添加集合
  • addAll(int index,Collection<? extends E> c) 在列表指定索引添加集合
  • removeAll(Collection<? > c) 移除包含集合内的全部元素
  • retainAll(Collection<? > c) 移除集合内没有的元素
  • iterator() 返回一个迭代器
  • subList(int fromIndex,int toIndex) 截取子数组
  • forEach(Consumer<? super E> action) 加强for循环
  • removeIf(Predicate<? super E> filter) 删除元素
  • replaceAll(UnayOperator operator) 替换指定元素
  • sort(Comparator<? super E>) 排序
  • isEmpty() 是否为空
微信关注【面试情报局】咱们一块儿干翻面试官。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程