jdk阅读day1-Boolean及Integer
今天开始看jdk，从最简单的封装对象看起，就先看了Boolean/Integer，遇到了几个问题。
（PS:由于不熟悉这里的操作，所以有些部分排版很乱，正慢慢修改）
跳过的部分：bitCount（int）、reverse（int）、reverseBytes(int)、
没看懂的部分：rotateLeft/right(int,int)、sigNum(int)
跳过和没看懂大部分都是不懂运算，位运算太可怕了，告辞
1.如何看源码的问题。
今天豹子看到了我看源码的方式，痛心疾首地向我传授了一点经验。看源码应该动态地看，例如在idea中，新建一个工程，在工程中，首先把源码调出来，大致浏览一下类里面有哪些方法，有哪些变量，在了解之后，新建test来测试每个方法，在遇到较复杂的方法时，还可以调试代码来理清它的前后关系。然后以下是我今天看源码产生的疑惑以及收获。
1.serialversionUID的作用
用于java反序列化时的版本比对。如果版本不一致的话，会产生InvalidCastException异常。
blog：http://swiftlet.net/archives/1268
2.java的序列化和反序列化
序列化是指将对象保存成二进制字节码的过程，反序列化是把对象从二进制字节码还原成java对象的过程。因为一开始不清楚这个定义，就找了博文来看，博文里面讲了序列化和反序列化的底层实现，感觉对我来说还是有阅读难度的，先放在这。
blog：http://www.importnew.com/24490.html
PS：以上两个问题是我采用自己的方式看源码得到的问题，我是从头开始看，并且是在网页上看的，而且在方法中的细节我也特别注重，每个问题都想弄清楚，但这就导致了每个方法我都理得很艰难并且局限于细节。
3.关于Integer.toString(int,int)的实现
while (i <= -radix) {
buf[charPos--] = digits[-(i % radix)];
i = i / radix;
}
buf[charPos] = digits[-i];
if (negative) {
buf[--charPos] = '-';
}其中这一段我不太明白它的具体实现，但估计是进行一个把int型数进行数制转换的过程。
4.关于toUnsignedString0(int,int)
可以得知，Integer的toHexString，toBinaryString，toOtcalString内部都是由这个函数实现的，也就是数制转换的逻辑在它里面。
private static String toUnsignedString0(int val, int shift) {
// assert shift > 0 && shift <=5 : "Illegal shift value";
int mag = Integer.SIZE - Integer.numberOfLeadingZeros(val);//计算出该数进制转化后的长度
int chars = Math.max(((mag + (shift - 1)) / shift), 1);//计算出该数实际存储所需长度
char[] buf = new char[chars];
formatUnsignedInt(val, shift, buf, 0, chars);//这个函数用于把无符号int转换为buffer存进buf
// Use special constructor which takes over "buf".
return new String(buf, true);
}1.Integer.numberOfLeadingZeros(val)的实现，里面用了位运算。因为对位运算不熟悉，懵逼了好久。然后找了一篇blog，终于看懂了。该函数的功能是计算指定int值的二进制补码的从左开始的0的位数，即如果int为0，则应该返回32。
（参考blog：http://blog.csdn.net/u010667082/article/details/51819231)
2.把无符号int转化为buffer存进buf(假设val=15，shift=4)
static int formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
int charPos = len;
int radix = 1 << shift;//计算出所要转换的进制
int mask = radix - 1;//得出进制的掩码
do {
buf[offset + --charPos] = Integer.digits[val & mask];//(val&mask)=(val%(mask+1))，举个例子，假如所需转换进制为16，e.g. 15%16
val >>>= shift;//无符号数右移一位,e.g.15/16
} while (val != 0 && charPos > 0);
return charPos;
}3.getChars(int,int,char)
没有看懂，先跳过。
4.Integer.parsInt(int,int,char)
（参考blog：http://blog.csdn.net/stu_wanghui/article/details/38564177）
public static int parseInt(String s, int radix)
throws NumberFormatException
{
/*
* WARNING: This method may be invoked early during VM initialization
* before IntegerCache is initialized. Care must be taken to not use
* the valueOf method.
*/
//下面redix要在2-36中
if (s == null) {
throw new NumberFormatException("null");
}
if (radix < Character.MIN_RADIX) {
throw new NumberFormatException("radix " + radix +
" less than Character.MIN_RADIX");
}
if (radix > Character.MAX_RADIX) {
throw new NumberFormatException("radix " + radix +
" greater than Character.MAX_RADIX");
}
int result = 0;//产生的结果
boolean negative = false;//是否为负数
int i = 0, len = s.length();//i为当前指向的下标，len为字符串的长度
int limit = -Integer.MAX_VALUE;//这里为最大数的负数。因为下面的转换都是当作负数来处理的，统一把正数转为负数。所以要用-最大值来比较。
int multmin;//这是用来判断溢出的
int digit;//当前指向的数字(0-9)
//判断是否为'-'/'+'，或是否只有'-'/'+'
if (len > 0) {
char firstChar = s.charAt(0);
if (firstChar < '0') { // Possible leading "+" or "-"
if (firstChar == '-') {
negative = true;
limit = Integer.MIN_VALUE;
} else if (firstChar != '+')
throw NumberFormatException.forInputString(s);
if (len == 1) // Cannot have lone "+" or "-"
throw NumberFormatException.forInputString(s);
i++;
}
multmin = limit / radix;//用来判断是否溢出，为了方便理解，用正数举例：假设十进制的最大数为10，则multmin=10/10=1。假设此时result=10，此时下一个result = result*10+digit，此时result会溢出，但是int不会保存溢出的result，所以要在前面判断result是否大于multmin。
while (i < len) {//
// Accumulating negatively avoids surprises near MAX_VALUE
digit = Character.digit(s.charAt(i++),radix);
if (digit < 0) {
throw NumberFormatException.forInputString(s);
}
if (result < multmin) {//因为统一用负数来进行运算，所以是<，相当于-(result)>-(multmin)
throw NumberFormatException.forInputString(s);
}
result *= radix;
if (result < limit + digit) {//相当于-(result)>-(limit+digit),即判断是否溢出
throw NumberFormatException.forInputString(s);
}
result -= digit;//如果为正数，则为result+=digit
}
} else {
throw NumberFormatException.forInputString(s);
}
return negative ? result : -result;//如果为负数直接返回，为正数返回-result
} public static int parseUnsignedInt(String s, int radix)
throws NumberFormatException {
if (s == null) {
throw new NumberFormatException("null");
}
int len = s.length();
if (len > 0) {
char firstChar = s.charAt(0);
if (firstChar == '-') {
throw new
NumberFormatException(String.format("Illegal leading minus sign " +
"on unsigned string %s.", s));
} else {
if (len <= 5 || // Integer.MAX_VALUE in Character.MAX_RADIX is 6 digits
(radix == 10 && len <= 9) ) { // Integer.MAX_VALUE in base 10 is 10 digits
return parseInt(s, radix);
} else {
long ell = Long.parseLong(s, radix);
if ((ell & 0xffff_ffff_0000_0000L) == 0) {//因为long为64位，这里的Oxffff_ffff_0000_0000L低32位都是0，如果ell这个数
//超过了低32位，它做&运算就的等于0，就会到下面抛错；如果等于0，就说明没有溢出，那么就返回int型的数字
return (int) ell;
} else {
throw new
NumberFormatException(String.format("String value %s exceeds " +
"range of unsigned int.", s));
}
}
}
} else {
throw NumberFormatException.forInputString(s);
}
}5.IntegerCache
Integer的缓存类，它会在Integer类被第一次使用时把-128-127（这个127可认为调整）的Integer初始化出来，然后放在cache[]中。当我们下一次再创建-128-1127范围的Integer时，它会直接在cache[]里找对象实例，而不是创建一个新的出来。
由此可以解释下面这一道题为何为true。
Integer int1 = Integer.valueOf("100");
Integer int2 = Integer.valueOf("100");
System.out.println(int1 == int2); private static class IntegerCache {
static final int low = -128;//最小值
static final int high;//最大值
static final Integer cache[];//存储这些对象实例的数组
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {//如果这个属性值不为空的话
try {
int i = parseInt(integerCacheHighPropValue);//把它转换为int
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7) 保证-128到127一定在其中
assert IntegerCache.high >= 127;//断言，一个程序要保证断言的结果为true才能正确运行，否则程序会发出警告并退出。
}
private IntegerCache() {}
}6.Integer.getInteger(String,Integer)
该方法是用来返回system中name为nm的属性值，如果没有该属性值或者该属性值不具有正确的数字格式，则返回val
public static Integer getInteger(String nm, Integer val) {
String v = null;
try {
v = System.getProperty(nm);
} catch (IllegalArgumentException | NullPointerException e) {//| 与 || 的区别：如果左边式子为true，则||只会计算左边，而|会两边都计算。同理，& 与 && 一样。
}
if (v != null) {
try {
return Integer.decode(v);
} catch (NumberFormatException e) {
}
}
return val;
}7.compareUnsigned(int,int)
public static int compareUnsigned(int x, int y) {
return compare(x + MIN_VALUE, y + MIN_VALUE);//MIN_VALUE = 1000 0000 0000 0000 ,加上只改变符号位（最高位），使得它们可以比较
}8.Integer.highestOneBit(int)
public static int highestOneBit(int i) {
// HD, Figure 3-1
i |= (i >> 1);//使得i最高位及i的下一位都为1
i |= (i >> 2);//依次类推
i |= (i >> 4);
i |= (i >> 8);
i |= (i >> 16);//使得i的最高位及其以下都为1
return i - (i >>> 1);//无符号右移并相减，使得i只剩下最高位的1
}