《面试与源码》ArrayList——ArrayList对序列化还有优化？

最新推荐文章于 2024-02-06 20:58:05 发布

陈小志同学

最新推荐文章于 2024-02-06 20:58:05 发布

阅读量318

点赞数 2

文章标签： java ArrayList 源码面试题

本文链接：https://blog.youkuaiyun.com/qq_39715219/article/details/103606018

版权

那一天，我看着电脑里的一堆笔记陷入沉思，有一个声音在我脑海浮现

“Co Co Da Yo ！”，“你走开！”

“想明白生命的意义吗？想真正的活着吗？”，“大哥你走错片场了吧？”

“要不把笔记整理一下，写点文章？”，“试试？”，“干就完事了！奥利给！”

引言

大概在一年半前开始去深入学习Java，看了一些书，看了很多大佬的博客，记了很多笔记。

我本人依旧是一个技术栈很浅的菜鸟，这几天看到@敖丶丙的文章，也想改变一下自己以前枯燥的学习方式，打算先整理自己之前的资料，希望可以和大家共同进步，学无止境。

正文

我忐忑的看着面试官，等待着他的提问。

能简单聊一下ArrayList吗？

心里暗自窃喜，这个简单我都背了20遍了

ArrayList中的值是可以重复的、且有序的（有序是指插入和取出有序）。
ArrayList底层通过数组实现，扩容时创建新的数组。
ArrayList不是线程安全的。

看着我都快憋不住的笑容，面试官微微一笑

可以讲讲创建ArrayList对象时的几种初始化方式吗？

这可难不倒我。

如果通过无参构造器创建ArrayList，那么会在第一次执行add方法时进行扩容，创建大小为10的数组。

通过有参构造器创建ArrayList有两种方式，一种通过传参值在构造方法中创建传参大小的数组，另一种通过传入一个集合，返回一个新的ArrayList。

源码分析

成员变量

private transient Object[] elementData;
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private int size;
private static final int DEFAULT_CAPACITY = 10;

构造方法


public ArrayList(int initialCapacity) {
    
    if (initialCapacity > 0) {   //initialCapacity大于0初始化固定大小的数组  
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) { //initialCapacity等于0初始化空数组   
        this.elementData = EMPTY_ELEMENTDATA;
    } else {  //其他情况抛出参数不合法异常
        throw new IllegalArgumentException("Illegal Capacity: "+
            initialCapacity);
    }
}

public ArrayList() {
    //初始化空数组
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

public ArrayList(Collection<? extends E> c) {
    //将集合转换为数组，toArray()返回的值可能不是Object[]类型。
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            //创建新的Object[]数组
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

Tip：为什么传参是数组的构造器在调用toArray( )后还需要再调用copyOf( )创建一次数组？

因为集合的toArray( )方法不一定会返回Object[ ]，举个例子：

Integer [] str = {1,2};
List<Integer> list = Arrays.asList(str);
System.out.println(list.toArray().getClass());
//返回class [Ljava.lang.Integer;

返回的Integer[ ]会使ArrayList即使不使用泛型也无法存放Integer及其子类外的数据.

面试官点了点头，（内心：这小子好像还可以）

你刚刚提到了无参构造器第一次执行add方法时会扩容，你可以详细讲讲扩容流程吗

这啥呀，我抓了抓脑袋。

ArrayList每一次执行add方法会判断当前size值是否大于数组，如果大于则进行扩容，默认情况下扩容1.5倍。

如果扩容1.5倍后数组大小在integer最大值和最大值减8之间，则扩容大小为integer最大值减8。

如果所需数组大小大于integer最大值减8则扩容数组至integer最大值，所需数组大小大于integer最大值则抛出异常。

源码分析

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  //判断数组是否扩容，size初始化为0
    elementData[size++] = e;  //为数组赋值
    return true;
}

计算当前数组所需的最小容量

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    /*如果当前数组为空，且minCapacity小于10，则将minCapacity设置为10，
    否则输出当前minCapacity*/
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //DEFAULT_CAPACITY值为10
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}


private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0) //当数组的下标大于当前数组大小时
        grow(minCapacity);	//扩容
}

Tip ：modCount变量继承自AbstractList类，每次在进行删除和添加时，这个数值都会加1，目的是在迭代时做判断，在迭代时如果删除或添加数据都会抛出异常。

private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 数组默认情况下扩容1.5倍

    /*当数组扩容1.5倍后大于Integer.MAX_VALUE，newCapacitity会溢出，值为负数，进入当前判断将        
    newCapacity 设置为当前数组期望大小*/
    if (newCapacity - minCapacity < 0) 
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0) // 当数组扩容1.5倍后大于MAX_ARRAY_SIZE时，进入 hugeCapacity( )方法。
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity); // 创建一个新的数组，大小为扩容后的大小
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0)  // 溢出抛出数组越界异常
        throw new OutOfMemoryError();

    /*如果所需数组小于MAX_ARRAY_SIZE则设置数组容量为MAX_ARRAY_SIZE
    如果所需数组大于MAX_ARRAY_SIZE则设置数组容量为 Integer.MAX_VALUE*/
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

面试官点了点头，脸上的笑容更加灿烂了（内心：我就不信难不倒你！！！）

你有了解过ArrayList对序列化的优化吗

我太难了，QAQ ，还好我早有准备。

ArrayList使用transient 修饰elementData数组，因此在序列化时elementData数组是不会被序列化的。

为什么要这样做呢？因为elementData数组不一定是满的，可能数组的大小是15，但是只有11个数据，我们没有必要序列化整个数组只需要序列化存在的数据即可，这样做可以加快序列化的速度、减小序列化之后的文件大小。

因此ArrayList重写了writeObject和readObject方法，在这两个方法中遍历获取数组中的数据。

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }

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

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;

    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in capacity
    s.readInt(); // ignored

    if (size > 0) {
        // be like clone(), allocate array based upon size not capacity
        int capacity = calculateCapacity(elementData, size);
        SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
        ensureCapacityInternal(size);

        Object[] a = elementData;
        // Read in all elements in the proper order.
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}