(JAVA)ConcurrentHashMap initialCapacity 手动计算初始化容量大小过程

(JAVA)ConcurrentHashMap initialCapacity 手动计算初始化容量大小过程

package com.lius.test;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * (JAVA)ConcurrentHashMap initialCapacity 手动计算初始化容量大小过程
 * 
 * 第一步：int cap = ((initialCapacity>=(MAXIMUM_CAPACITY/2))?MAXIMUM_CAPACITY:
 * 							initialCapacity+(initialCapacity/2) + 1);
 * initialCapacity如果大于最大值的一半,cap直接取最大值，否则取initialCapacity+initialCapacity/2再+1的值作为cap变量值
 * 第二部: cap = (cap-1)|/2|/4|/8|/16|/32;  解释:|/ => [cap/=2; cap|=cap;]
 * cap先自减1，然后除以2在进行或运算，...除以32再进行或运算，取最终结果
 * 第三步: cap = (cap<0)?1:(cap>=MAXIMUM_CAPACITY)?MAXIMUM_CAPACITY:cap+1;  
 * 如果cap小于0,cap取1，如果大于最大值，cap就取最大值，如果cap在0与最大值之间，cap就取cap+1
 * @author lius
 */
public class testMap {
	private static final int MAXIMUM_CAPACITY = 0x40000000;
	//initialCapacity = 64
	private Map<String,Object> mapContainer = new ConcurrentHashMap<>(64);

	//mainProgram Point
public static void main(String[] args) {
	
	testMap tMap = new testMap();
	tMap.run();
}

private void run() {
	//initialCapacity = 64
	int initialCapacity = 64;
	//MAXIMUM_CAPACITY >>> 1  equals MAXIMUM_CAPACITY/=2;
	//initialCapacity >>> 1   equals initialCapacity/=2;
	/**
	 * int cap = ((initialCapacity  >= (MAXIMUM_CAPACITY/2)) ?
            MAXIMUM_CAPACITY :
            	initialCapacity + (initialCapacity/2) + 1);
	 */
	//int cap = 64+(64/2+1);    97
	int cap = ((initialCapacity  >= (MAXIMUM_CAPACITY >>> 1)) ?
            MAXIMUM_CAPACITY :
            	initialCapacity + (initialCapacity >>> 1) + 1);
	//cap = (cap-1)|/2|/4|/8|/16|/32; 
	cap = tableSizeFor(cap);
}
//
private static final int tableSizeFor(int c) {
    /**
     * n = (n-1)|/2|/4|/8|/16|/32; 
     */
	int n = c - 1;//	n = c-1;
    n |= n >>> 1; //	n/=2;  96|48  0b1100000|0b0110000 => 0b1110000  112
    n |= n >>> 2; //	n/=4;  112|28 0b1110000|0b0011100 => 0b1111100  124
    n |= n >>> 4; //	n/=8;  124|31 0b1111100|0b0011111 => 0b1111111	127
    n |= n >>> 8; //    n/=16; 127|7  0b1111111|0b0000111 => 0b1111111  127
    n |= n >>> 16;//    n/=32; 127|3  0b1111111|0b0000011 => 0b1111111  127
    //n == 127; 127<0?1:(n>=max?max:127+1) => 128
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    //return 128;
}
}