HashMap的源码，在jdk1.5中相比jdk1.4，改动不大，有几个方面
1 jdk1.5中引入了范型，在HashMap中也有体现
2 引入了另一个hash值的计算方式，不过默认是关闭状态，可以通过设置jvm的参数开启
private static int oldHash(int h) { h += ~(h << 9); h ^= (h >>> 14); h += (h << 4); h ^= (h >>> 10); return h; } private static int newHash(int h) { h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); } static int hash(int h) { return useNewHash ? newHash(h) : oldHash(h); } // -XX:+UseNewHashFunction or -XX:+AggressiveOpts 启动新的hash计算 private static final boolean useNewHash; static { useNewHash = false; }
3 代码的小优化
public V get(Object key) { // key为null时，取value的过程抽离到一个方法里 if (key == null) return getForNullKey(); int hash = hash(key.hashCode()); for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || key.equals(k))) return e.value; } return null; }
HashMap的源码，在jdk1.6中相比于jdk1.5也没什么改动，在这个版本开始，开始启用新的hash计算方式，把以前的废弃了
static int hash(int h) { h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); }
在jdk1.7中，相比与jdk1.6，变动也不是很大。
在jdk1.7中，HashMap的初始数组长度，没有设置了。可能出于内存有效使用的考虑。
// 构造方法里并没有初始化数组 public HashMap(int initialCapacity, float loadFactor) { 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; // 数组增长阀值，先设置成数组的初始长度 threshold = initialCapacity; init(); } public V put(K key, V value) { // 如果数组没有初始化，开始初始化 if (table == EMPTY_TABLE) { inflateTable(threshold); } .... }
这里引入了一个新方法inflateTable，初始化数组
// 初始化数组 private void inflateTable(int toSize) { // 计算确认初始化数组的长度 int capacity = roundUpToPowerOf2(toSize); // 重新给数组长度的阀值赋值 threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1); table = new Entry[capacity]; // 这里是判断是否需要给hash值生成添加生成因子，减少hash碰撞的概率 initHashSeedAsNeeded(capacity); } // 获得初始化数组的长度 private static int roundUpToPowerOf2(int number) { // 分几种情况 // 1 number超过数组长度限制最大值，则返回数组长度的最大值 // 2 number小于或者等于1， 则返回1 // 3 否则返回Integer.highestOneBit((number - 1) << 1)，这个表示number二进制表示时，最左边位数的值为1，其他位为0时的值 // 比如 0000 0000 0000 0000 1011 0011 0000 0000 计算后值为 0000 0000 0000 0000 1000 0000 0000 0000 return number >= MAXIMUM_CAPACITY ? MAXIMUM_CAPACITY : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1; } // 初始化是否使用hash值生成的生成因子 final boolean initHashSeedAsNeeded(int capacity) { // 判断是否已经使用了生成因子，hashSeed＝0表示未使用 boolean currentAltHashing = hashSeed != 0; // 判断是否使用生成因子 boolean useAltHashing = sun.misc.VM.isBooted() && (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD); boolean switching = currentAltHashing ^ useAltHashing; if (switching) { hashSeed = useAltHashing ? sun.misc.Hashing.randomHashSeed(this) : 0; } return switching; }
这里在看下hash值的生成
final int hash(Object k) { int h = hashSeed; // 如果key对象是字符串，则换个方式生成hash值 if (0 != h && k instanceof String) { return sun.misc.Hashing.stringHash32((String) k); } // 添加生成因子 h ^= k.hashCode(); // This function ensures that hashCodes that differ only by // constant multiples at each bit position have a bounded // number of collisions (approximately 8 at default load factor). h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); }
上面提到一个方法Integer.highestOneBit，可能看着挺困惑的，这个是Integer里的一个方法。
// 或者i最高位为1，其他位为0时的值 // 如：0000 0000 0000 0000 1011 0011 0000 0000 计算后值为 0000 0000 0000 0000 1000 0000 0000 0000 public static int highestOneBit(int i) { // 开始位运算 i |= (i >> 1);// i左移1位，在和i值或运算，得到值的最高位和第2位都为1 （如果最高为到最右端不到2位，则最高位到最右端都为1） i |= (i >> 2);// 新的i左移2位，在和i值或运算，得到值的最高位到第4位都为1 （如果最高为到最右端不到4位，则最高位到最右端都为1） i |= (i >> 4);// 新的i左移4位，在和i值或运算，得到值的最高位到第8位都为1 （ 如果最高为到最右端不到8位，则最高位到最右端都为1） i |= (i >> 8);// 新的i左移8位，在和i值或运算，得到值的最高位到第16位都为1 （如果最高为到最右端不到16位，则最高位到最右端都为1） i |= (i >> 16);// 新的i左移16位，在和i值或运算，得到值的最高位到第32位都为1 （如果最高为到最右端不到32位，则最高位到最右端都为1） // 非最高位设置为0 return i - (i >>> 1); }