关于ArrayList的初始容量以及扩容的效率问题

分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.csdn.net/jiangjunshow

也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！

               

论坛的一个问题：

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

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

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

我们看一下ArrayList的源代码

[java] view plain copy print ?

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

    public ArrayList() { this(10);    }

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

[java] view plain copy print ?

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. }  

    public ArrayList(int initialCapacity) { super();        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal Capacity: "+                                               initialCapacity); this.elementData = new Object[initialCapacity];    }

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

再看看add方法

[java] view plain copy print ?

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

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

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

[java] view plain copy print ?

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.    }  

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

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

[c-sharp] view plain copy print ?

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

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

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

[java] view plain copy print ?

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

elementData = Arrays.copyOf(elementData, newCapacity);

总结：

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

1千需要分配 11次

1万一级需要分配17次

10万 需要分配23次

100万需要分配28次

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

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

           

给我老师的人工智能教程打call！http://blog.csdn.net/jiangjunshow