面试官问你数组和ArrayList怎么答？

我在想每一个人在面试的时候都会被问到集合相关的问题，有好大一部分人在回答的时候并无那么多的逻辑性，一般都是想到哪里说到哪里，这篇文章大概的捋一捋关于集合的相关问题。

在每种编程语言中，都会有循环、数组、流程控制语句，数组是一种线性表数据结构，内存空间是连续的，保存的数据类型也是一致的。

正是由于这两点，数组的随机访问才会很是的高效，这同时也是一把双刃剑，使得数组的其余操做效率变得很低，好比说，增长，删除，为了保持数组里面数据的连续性，就会作大量的消耗性能的数据迁移操做。

针对数组这种类型，java中有容器类，好比ArrayList，ArrayList是对数组的包装，在底层就是数组实现的，由于数组在定义的时候必须是指定的长度，定义以后就没法再增长长度了，就是说不可能在原来的数组上接上一段，因此ArrayList就解决了这个问题，当超过数组容量的时候，ArrayList会进行扩容，扩容以后的容量是以前的1.5倍，而后再把以前数组中的数据复制过来。

接下来，咱们看下ArrayList的源码：

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
复制代码

源码中数组最大的容量是Integer.MAX_VALUE -8，为何要减去8 呢，这个是上面的定义上面的注释：

/**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
复制代码

首先是一些VM在数组中保存的头信息；尝试着去分配更大的数组可能会致使OutOfMemoryError，请求的数组大小超过了VM的限制。

在看这句代码的时候，脑中有没有出现两个大大的问号？？

首先，有没有想到为何这个数组属性须要用 transient修饰？

（想知道这个关键字是干什么的，能够看下我以前的一篇文章：面试问你java中的序列化怎么答？）

transient Object[] elementData; // non-private to simplify nested class access
复制代码

你们能够随便的想一下，若是是面试的时候，你会怎么回答？

因为 ArrayList 是基于动态数组实现的，因此并非全部的空间都被使用。所以使用了 transient 修饰，能够防止被自动序列化。

所以 ArrayList 自定义了序列化与反序列化，具体能够看 writeObject 和 readObject 两个方法。

须要注意的一点是，当对象中自定义了 writeObject 和 readObject 方法时，JVM 会调用这两个自定义方法来实现序列化与反序列化。

第二个问题：这个属性的类型为何是Object而不是泛型？

这里和你们说下：

java中泛型运用的目的就是对象的重用，就是同一个方法，能够支持多种对象类型，Object和泛型在编写的时候其实没有太大的区别，只是JVM中没有T这个概念，T只是存在编写的时候，进入虚拟机运行的时候，虚拟机会对这种泛型标志进行擦除，也就是替换T到指定的类型，若是没有指定类型，就会用Object替换，同时Object能够new Object()，就是说能够实例化，而T则不能实例化。在反射方面来讲，从运行时,返回一个T的实例时,不须要通过强制转换,而后Object则须要通过转换才能获得。

当咱们试图向ArrayList中添加一个元素的时候，java会自动检查，以确保集合中确实还有容量来添加新元素，若是没有，就会自动扩容，下面是核心代码，我已经在代码里加了注释，帮助你们可以更好的理解：

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
复制代码

上面这段代码中有个 变量 modCount++，看到这里的时候确实有些疑惑，我找了下，这个变量是在AbstractList中定义的protected修饰的全局变量，这个变量是记录告终构性改变的次数，结构性改变就是说修改列表大小的操做。

ArrayList是一个线程不安全的类，这个变量就是用来保证在多线程环境下使用迭代器的时候，同时又对集合进行了修改，同一时刻只能有一个线程修改集合，若是多于一个，就会抛出ConcurrentModficationException。

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:
        //接下来，是把原数组d 数据复制到新的数组里
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    
        private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
            //当 Integer-8 依然没法知足需求，就会取Integer的最大值
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
复制代码

接下来咱们看下，向指定位置添加元素是什么样的：

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++;
    }
复制代码

能够看到，当一个集合足够大的时候，add操做向数组的尾部添加元素效率仍是很是高的，可是当向指定的位置添加元素的时候，也是须要大量的移动复制操做：System.arraycopy()。

到这里，ArrayList最大的优点是什么呢？咱们在平时的开发中涉及到容器的时候为何会选择List家族的成员，而不直接选择数组呢？你们回想一下本身以前敲代码的经历，答案也就出来了：

ArrayList封装了大部分数组的操做方法，好比插入、删除、搬移数据等等，都在集合内部帮你作好了，还有就是支持动态扩容，这点是数组不能比拟的。

这里须要注意一点，当咱们在开始定义集合的时候，若是知道咱们须要多大的集合，就应该在一开始就指定集合的大小，由于在集合的内部来进行数据的搬移，复制也是很是耗时的。

那么数组在何时会用到呢？

一、java ArrayList没法存储基本类型，int，long，若是保存的话，就须要封装为Integer、Long，而自动的拆装箱，也有性能的消耗，因此总结下这点就是说若是要保存基本类型，同时还特别关注性能，就可使用数组。

二、若是对数据的数量大小已知，操做也很是简单，也不须要ArrayList中的大部分方法，也是能够直接使用数组的。

这样的分享我会一直持续，你的关注、转发和好看是对我最大的支持，感谢。

关注公众号，里面会有更多精彩的内容