arrayList, StringBuilder扩容的问题

论坛的一个问题：

有这样一段很简单的代码: 
ArrayList <DataVO> a = new ArrayList <DataVO>(); 

a.addAll(b); 
a.addAll(c); 

其中DataVO是一个实体类，b和c都是一个ArrayList <DataVO>类型。 
如果当b，c数据量很大的时候，请问这样一段代码是不是会很影响效率？

 

 

我们看一下ArrayList的源代码

[java]  view plain  copy

1. public ArrayList() {  
2. s(10);  
3. }  

可见默认的构造器，其调用了参数为10的构造函数

[java]  view plain  copy

1. public ArrayList(int initialCapacity) {  
2. er();  
3.     if (initialCapacity < 0)  
4.         throw new IllegalArgumentException("Illegal Capacity: "+  
5.                                            initialCapacity);  
6. s.elementData = new Object[initialCapacity];  
7. }  

这个带参数的构造函数，初始化了一个长度为初始容量的数组。

 

再看看add方法

[java]  view plain  copy

1.    public boolean add(E e) {  
2. ensureCapacity(size + 1);  // Increments modCount!!  
3. elementData[size++] = e;  
4. return true;  
5.    }  

这里面的第一行，就是确信当前容量是否能容下新增加的对象

[java]  view plain  copy

1.    public void ensureCapacity(int minCapacity) {  
2. modCount++;  
3. int oldCapacity = elementData.length;  
4. if (minCapacity > oldCapacity) {  
5.     Object oldData[] = elementData;  
6.     int newCapacity = (oldCapacity * 3)/2 + 1;  
7.         if (newCapacity < minCapacity)  
8.     newCapacity = minCapacity;  
9.            // minCapacity is usually close to size, so this is a win:  
10.            elementData = Arrays.copyOf(elementData, newCapacity);  
11. }  
12.    }  

此方法里，一旦发现容量不足，会自动扩充容量，新的大小是

[c-sharp]  view plain  copy

1. int newCapacity = (oldCapacity * 3)/2 + 1;  

也就是原有容量的1.5倍+1。然后通过底层的复制方法将原有数据复制过来

[java]  view plain  copy

1. elementData = Arrays.copyOf(elementData, newCapacity);  

 

 

总结：

    如果数据量很大，那么造成数组重新分配的次数会增加，但对于一般的数据量下，

1千需要分配 11次

1万一级需要分配17次

10万 需要分配23次

100万需要分配28次

 

所以，大家根据实际情况，大致分配一个初始化的容量还是有必要的。但是如果你初始容量太大，而数据增长很慢，那么就在浪费内存了。

如何取舍，还是看具体的应用场景了。

2 StringBiulder 扩容

比如ArrayList、LinkedLlist、StringBuilder、StringBuffer、HashMap、HashSet等等，以StringBuilder为例：

（1）StringBuilder()　　　　　　// 默认分配16个字符的空间

（2）StringBuilder(int size)　　// 默认分配size个字符的空间

（3）StringBuilder(String str)　// 默认分配16个字符+str.length()个字符空间

可以通过类（这里指的不仅仅是上面的StringBuilder）的来设定它的初始化容量，这样可以明显地提升性能。比如StringBuilder吧，length表示当前的StringBuilder能保持的字符数量。因为当StringBuilder达到最大容量的时候，它会将自身容量增加到当前的2倍再加2，无论何时只要StringBuilder达到它的最大容量，它就不得不创建一个新的字符数组然后将旧的字符数组内容拷贝到新字符数组中—-这是十分耗费性能的一个操作。试想，如果能预估到字符数组中大概要存放5000个字符而不指定长度，最接近5000的2次幂是4096，每次扩容加的2不管，那么：

（1）在4096 的基础上，再申请8194个大小的字符数组，加起来相当于一次申请了12290个大小的字符数组，如果一开始能指定5000个大小的字符数组，就节省了一倍以上的空间

（2）把原来的4096个字符拷贝到新的的字符数组中去

这样，既浪费内存空间又降低代码运行效率。所以，给底层以数组实现的集合、工具类设置一个合理的初始化容量是错不了的，这会带来立竿见影的效果。但是，注意，像HashMap这种是以数组+链表实现的集合，别把初始大小和你估计的大小设置得一样，因为一个table上只连接一个对象的可能性几乎为0。初始大小建议设置为2的N次幂，如果能估计到有2000个元素，设置成new HashMap(128)、new HashMap(256)都可以。

void expandCapacity(int minimumCapacity) {
    int newCapacity = value.length * 2 + 2;
    if (newCapacity - minimumCapacity < 0)
        newCapacity = minimumCapacity;
    if (newCapacity < 0) {
        if (minimumCapacity < 0) // overflow
            throw new OutOfMemoryError();
        newCapacity = Integer.MAX_VALUE;
    }
    value = Arrays.copyOf(value, newCapacity);
}