阿里开发规范中说明:
【推荐】集合初始化时,推荐使用显示指定初始化大小。
本文就来聊聊很多时候大家都喜欢使用集合的默认初始化大小,然后怎么掉进坑里的。
概述
集合初始化通常进行分配容量、设定特定参数等相关工作。我们以使用频率相对较高的ArrayList和HashMap为例,简要说明初始化的相关工作,并解释为什么在任何情况下,都需要显示地为集合容器设定初始化大小。
ArrayList
是存储同一类元素、存储顺序与存放顺序一样的集合,可重复,底层采用数组实现的集合。
HashMap
是存储K-V键值对的哈希式结构集合。
分析两者的初始化相关源码,洞悉它们的容量分配、参数设定等相关逻辑,有助于更好的理解集合特性,从而提升代码质量。
ArrayList
先看其源码,java.util.ArrayList
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
private static final long serialVersionUID = 8683452581122892189L;
//默认容量大小
private static final int DEFAULT_CAPACITY = 10;
/**
* A constant holding the maximum value an {@code int} can
* have, 2<sup>31</sup>-1.
* 2的31次方再减1
*/
@Native public static final int MAX_VALUE = 0x7fffffff;
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//空间表示方法
transient Object[] elementData; // non-private to simplify nested class access
//用于空实例的共享空数组实例。
private static final Object[] EMPTY_ELEMENTDATA = {};
//共享空数组实例,用于默认大小的空实例。我们将其与空元素数据区分开来,
//以了解当添加第一个元素时候何时膨胀。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//真实大小
private int size;
//手工指定初始容量大小
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
//指定初始化容量大小initialCapacity大于0,
//然后创建一个数组大小为initialCapacity
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//空数组
this.elementData = EMPTY_ELEMENTDATA;
} else {
//参数小于0,跑一个非法参数的异常
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
}
}
/**
* Constructs an empty list with an initial capacity of ten.
*/
//initialCapacity初始化值为10
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//将指定的元素追加到此列表的结尾
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//如果没有指定初始容量大小
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//DEFAULT_CAPACITY==10,minCapacity=1
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
//确保扩展能力
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 溢出意识代码,
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//扩展容量大小
private void grow(int minCapacity) {
// 防止扩容1.5倍之后,超过int的表示范围-----A
int oldCapacity = elementData.length;
//JDK1.6之前扩展50%或者50%-1,
//下面的oldCapacity >> 1表示集合容量的二进制数向右移动一位,
//差不多就是减半,比如oldCapacity=11,11的二进制1011,
//1011向右移动一位变成101,则下面的计算为
//int newCapacity=11+5
int newCapacity = oldCapacity + (oldCapacity >> 1);
//若果11+5=16-minCapacity<0,说明,本次扩展成功,
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//若果11+5=16>MAX_ARRAY_SIZE,
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 最好是初始化容量接近于真实使用容量大小
//使用 Arrays.copyOf复制数组
elementData = Arrays.copyOf(elementData, newCapacity);
}
//巨大容量
private static int hugeCapacity(int minCapacity) {
//会导致OOM
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
//JDK1.6扩容的部分代码为下面
public void ensureCapacity(int var1) {
++this.modCount;
int var2 = this.elementData.length;
if (var1 > var2) {
Object[] var3 = this.elementData;
//扩容后容量=(原来容量*3)/2+1
//也就是是原来的1.5倍+1
int var4 = var2 * 3 / 2 + 1;
if (var4 < var1) {
var4 = var1;
}
this.elementData = Arrays.copyOf(this.elementData, var4);
}
}
}
现在需要将1000个数据存储到一个ArrayList
中,采用默认构造函数,则需要13次扩容才可以完成这1000数据的存储,相反,如果在初始化的时候直接给ArrayList
初始化大小为1000的容量,一次性搞定。从而避免被动扩容和数组复制的额外开销。如果数据更大或超大,却没有注意初始容量分配的问题,那么无形中会给系统的性能损坏造成非常大的影响,搞不好还有可能OOM(Out Of Memory)
。
10-->15--->22--->33-->49-->74-->111-->166-->249-->373-->559-->838-->1000+
//默认初始化
ArrayList arrayList=new ArrayList();
//初始化大小为1000
ArrayList arrayList=new ArrayList(1000);
HashMap
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
/**
* The default initial capacity - MUST be a power of two.
* 初始化容量大小为16,就算是指定也必须是2的n次方
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大容量MUST be a power of two <= 1<<30.
static final int MAXIMUM_CAPACITY = 1 << 30;
//加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* The next size value at which to resize (capacity * load factor).
* 下次扩展的阈值=容量*加载因子
*/
int threshold;
//指定初始容量大小initialCapacity,加载因子loadFactor
public HashMap(int initialCapacity, float loadFactor) {
//初始容量值小于0,抛出参数非法异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//如果初始容量大于最大容量,则初始容量默认为最大容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//加载因子参数校验
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
//初始化扩容阈值
this.threshold = tableSizeFor(initialCapacity);
}
/**
* Returns a power of two size for the given target capacity.
* 返回一个2的n次方的数
* 如果cap=10,则返回比10大的最近的2的n次方的数,即就是16=2的4次方
* 如果cap=8,则返回8=2的3次方
*/
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//如果当前集合大小比阈值大,则扩容
if (++size > threshold) resize();
}
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
//真实容量大于最大容量2^30
if (oldCap >= MAXIMUM_CAPACITY) {
//修改阈值为int的最大值(2^31-1),这样以后就不会扩容了
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//两倍的阈值
newThr = oldThr << 1;
}
else if (oldThr > 0)
//将初始容量设置为阈值
newCap = oldThr;
else {
//零初始阈值表示使用默认值
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//.....
}
}
为了提高运算速度,设定HashMap容量打下欧威2的n次方,这样的方式使计算落槽为止更快。threshold是以2的倍数增加,那么上面的例子存1000个数据到HashMap中则需要一下7次;HashMap扩容还是有不小的成本的,如果提前能够预估出HashMap内要存放的元素个数,就可以在初始化时设置合理容量大小,避免了不断扩容带来的性能损耗。
16-->32-->64-->128-->256-->512-->1000+
HashMap<String,Object> hashMap=new HashMap<>();
HashMap<String,Object> hashMap=new HashMap<>(1024);
总结
综上所述,集合初始化时,指定集合初始容量大小。如果暂时无法确定集合大小的时候,才使用默认值,所以当你在使用集合的时候,请考虑考虑初始容量的大小,能记住各种集合初始大小是最好,如果实在是记不得,请在使用的时候看一下源码,因为源码中都有其初始化大小。ArrayList
默认大小为10,HashMap
默认大小为16。