ArrayList 扩容

 

 

下面列出了Array和ArrayList的不同点：
Array可以包含基本类型和对象类型，ArrayList只能包含对象类型。
Array大小是固定的，ArrayList的大小是动态变化的。
ArrayList提供了更多的方法和特性，比如：addAll()，removeAll()，iterator()等等。
对于基本类型数据，集合使用自动装箱来减少编码工作量。但是，当处理固定大小的基本数据类型的时候，这种方式相对比较慢。

 

ArrayList可以算是Array的加强版，（对array有所取舍的加强）。

另附分类比较：

存储内容比较：

• Array数组可以包含基本类型和对象类型，
• ArrayList却只能包含对象类型。

但是需要注意的是：Array数组在存放的时候一定是同种类型的元素。ArrayList就不一定了，因为ArrayList可以存储Object。

空间大小比较：

• 它的空间大小是固定的，空间不够时也不能再次申请，所以需要事前确定合适的空间大小。
• ArrayList的空间是动态增长的，如果空间不够，它会创建一个空间比原空间大约0.5倍的新数组，然后将所有元素复制到新数组中，接着抛弃旧数组。而且，每次添加新的元素的时候都会检查内部数组的空间是否足够。（比较麻烦的地方）。

 

 

ArrayList 几个重要属性之一

1，首先是默认初始值的大小：

private static final int DEFAULT_CAPACITY = 10;,

2，接着是一个默认的空对象数组：

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

3，然后是ArrayList 实际数据存储的一个数组：

transient Object[] elementData;

4，elementData 的大小：

private int size;

来个Demo，看一下ArrayList 的使用

1，首先来个辅助方法，用于获得ArrayList 的容量大小，由于即elementData 数据的长度，由于elementData 是私有的属性，所以，我们可以用反射的机制来进行获取。如下。

        public static Integer getCapacity(ArrayList list) {
            Integer length = null;
            Class c = list.getClass();
            Field f;
            try {
                f = c.getDeclaredField("elementData");
                f.setAccessible(true);
                Object[] o = (Object[]) f.get(list);
                length = o.length;
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            return  length;
        }

2，看一下，如果构造ArrayList 对象的时候，如果在构造函数里面什么也不传，其会进行什么操作。可以看到，其进行的操作是，初始化了一个空的数组。

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

3，接下来我们调用无参构造函数，来创建一个对象。看一下其初始化容量是，以及大小是多少。最终的结果：容量：0，大小：0，

            ArrayList<String> list = new ArrayList<>();
            Integer length = getCapacity(list);
            int size = list.size();
            System.out.println("容量： " + length);
            System.out.println("大小： " + size);

4，接着，我们构造一个ArrayList，添加一个元素，看一下其容量。最终的结果，容量：10，大小：1，可以看出。也就是说如果ArrayList 构造函数中如果没有设置初始化的容量大小，在没有添加有元素的时候，其初始化容量是0，只有当添加第一个元素的时候，才会初始化容量才会设置成10.

            ArrayList<String> list = new ArrayList<>();
            Integer length = getCapacity(list);
            int size = list.size();
            System.out.println("容量： " + length);
            System.out.println("大小： " + size);

ArrayList 扩容机制

1，接下来，我们进行构造一个ArrayList 对象，同样调用的是无参构造函数。然后往里面添加11个对象，看起容量会如何进行动态扩展。最终结果，容量：15，大小：11

            ArrayList<String> list = new ArrayList<>();
            for (int i = 1; i <= 11; i++) {
                list.add("value" + i);
            }
            Integer length = getCapacity(list);
            int size = list.size();
            System.out.println("容量： " + length);
            System.out.println("大小： " + size);

2，要清楚其扩容机制，我们需要跟进去，看一下其add 方法，

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

首先肯定是得确保数组的容量够到，这样才不会包数组越界异常，IndexOutOfBoundsException。

3，看一下ensureCapacityInternal方法的实现：

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

4，具体扩容流程：

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;   // 原来的容量
    int newCapacity = oldCapacity + (oldCapacity >> 1);  // 新的容量，原来容量的1.5倍。
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)  // 如果大于ArrayList 可以容许的最大容量，则设置为最大容量。
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);  // 最终利用Arrays.coppy 进行扩容，生成一个1.5倍元素的数组。（即例子中的15个元素的数组。）
}

最后来个总结：

ArrayList 的内部实现，其实是用一个对象数组进行存放具体的值，然后用一种扩容的机制，进行数组的动态增长。
其扩容机制可以理解为，如果元素的个数，大于其容量，则把其容量扩展为原来容量的1.5倍。

 

 

 

参考：

https://blog.csdn.net/qq_32575047/article/details/78942965