Java源码 Integer
Integer的签名如下，继承了Number类并实现Comparable接口
public final class Integer extends Number implements Comparable<Integer>Comparable接口强行对实现它的每个类的对象进行整体排序。此排序被称为该类的自然排序，类的 compareTo 方法被称为它的自然比较方法。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射表中的键或有序集合中的元素，无需指定比较器。强烈推荐（虽然不是必需的）使自然排序与 equals 一致。所谓与equals一致是指对于类C的每一个e1和e2来说，当且仅当 (e1.compareTo((Object)e2)==0) 与e1.equals((Object)e2) 具有相同的布尔值时，类C的自然排序才叫做与equals一致
public interface Comparable<T> { public int compareTo(T o);}Number为抽象类，提供了实数基本类型的互相转换方法：int,long,short,byte,float,doubleNumber的基本实现类有java.lang.Byte，java.lang.Double，java.lang.Float，java.lang.Integer，java.lang.Long，java.lang.Short等
public abstract class Number implements java.io.Serializable { public abstract int intValue(); public abstract long longValue(); public abstract float floatValue(); public abstract double doubleValue(); public byte byteValue() { return (byte)intValue(); } public short shortValue() { return (short)intValue(); } private static final long serialVersionUID=-8742448824652078965L;}Integer类包装了int基本类型,所有Integer的实际值是存储在一个int类型的熟悉value上的，int存储占用4字节32位内存，第一位是符号位，所以int的最大值是2的31次幂减1，最小值是负2的31次幂，因此int的最大值是：0111 1111 1111 1111 1111 1111 1111 1111=0x7fffffff,int的最小值为负值，负数的表示为正值二进制的补码：
补码：反码加一源码：绝对值二进制反码：二进制按位取反负数最小值的正值为2的31次幂，正值的二进制为：1000 0000 0000 0000 00000 0000 0000 0000，二进制取反之后为：0111 1111 1111 1111 1111 1111 1111 1111，则正值的补码为：1000 0000 0000 0000 00000 0000 0000 0000，即int的最小值为：0x80000000
Integer有2个构造函数，可以传递一个int数字或者一个数字字符串，数字字符串会被转换成十进制的int数字。
private final int value; public static final int MIN_VALUE=0x80000000; public static final int MAX_VALUE=0x7fffffff; public static final int SIZE=32;//int存储位数 public Integer(int value) { this.value=value; } public Integer(String s) throws NumberFormatException { this.value=parseInt(s, 10); }Integer的实例方法，Integer实现了从Number类和Comparable接口以及Object继承的方法。
public byte byteValue() { return (byte)value; } public short shortValue() { return (short)value; } public int intValue() { return value; } public long longValue() { return (long)value; } public float floatValue() { return (float)value; } public double doubleValue() { return (double)value; } public String toString() { return toString(value); } public int hashCode() { return value; } //判断数字相等使用基本类型int值比较，直接使用==比较Integer的是地址。 public boolean equals(Object obj) { if (obj instanceof Integer) { return value==((Integer)obj).intValue(); } return false; } //此处调用了类的静态方法比较两个int型数字的大小 public int compareTo(Integer anotherInteger) { return compare(this.value, anotherInteger.value); } public static int compare(int x, int y) { return (x < y) ? -1 : ((x==y) ? 0 : 1); }Integer类内部有一个私有的静态内部类IntegerCache，该类缓存了一些常用的int值到缓存中，从而保证这些int可以直接获取而不用构造。最大值可以通过虚拟机参数java.lang.Integer.IntegerCache.high类配置，但是最小的为127.
private static class IntegerCache { static final int low=-128;//最小缓存int值 static final int high;//最大缓存int值，默认127 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) { int i=parseInt(integerCacheHighPropValue); i=Math.max(i, 127); // Maximum array size is Integer.MAX_VALUE h=Math.min(i, Integer.MAX_VALUE - (-low) -1); } high=h; cache=new Integer[(high - low) + 1]; int j=low; for(int k=0; k < cache.length; k++) cache[k]=new Integer(j++); } private IntegerCache() {} }Integer中的类方法：bitCount(int i),返回int数字的二进制原码中1出现的次数如Integer.bitCount(10)==2,10的二进制源码为1010,1出现2次。
1.两两一组相加,并且用该对应的两位来存储这个个数：二进制中先分割为2位计算，如108=01101100=0000 0000 0000 0000 0000 0000 0110 1100，第一个2位为00，出现1的个数为0+0=00，最后4个两位为：01,10,11,00,计算后的二进制为：0+1=01,1+0=01,1+1=10,0+0=00,即0101 1000,最后得到的二进制是：0000 0000 0000 0000 0000 0000 0101 1000
2.四四一组相加，并且用该对应的四位来存储这个个数：对两两一组相加相加的结果四四一组相加，即0000 0000 0000 0000 0000 0000 0101 1000进行四四一组相加，0101：01+01=0010，1000：10+00=0010,最后结果为：0000 0000 0000 0000 0000 0000 0010 0010
3.八八一组相加，并且用该对应的八位来存储这个个数：对四四一组相加相加的结果八八一组相加，即0000 0000 0000 0000 0000 0000 0010 0010进行八八一组相加，00100010：0010+0010=00000100最后结果为：0000 0000 0000 0000 0000 0000 0000 0100
4.十六十六一组相加，并且用该对应的十六位来存储这个个数：对八八一组相加相加的结果十六十六一组相加，即0000 0000 0000 0100：0000 0000 + 0000 0100=0000 0000 0000 0100最后结果为：0000 0000 0000 0000 0000 0000 0000 0100最后相加：0000 0000 0000 0000 + 0000 0000 0000 0100=0000 0000 0000 0000 0000 0000 0000 0100=4
计算过程：第一行：i=i - ((i >>> 1) & 0x55555555);i=0000 0000 0000 0000 0000 0000 0110 11000x55555555=0101 0101 0101 0101 0101 0101 0101 0101二位二进制中:原码-高位值=1出现的个数，（11-(11>>1)&01）=10=2（10-(10>>1)&01）=01=1（01-(01>>1)&01）=01=1（00-(00>>1)&01）=00=0i>>>1:原码值右移一位：01 10 11 00-->00 11 01 10(i >>> 1) & 0x55555555：原码中所有两位二进制高位值：00 01 01 00i - ((i >>> 1) & 0x55555555)：原码中所有两位二进制1的个数：01 01 10 00二进制减法的规则是低位不足向高位借位，二位二进制原码-高位值，这样在做减法的时候保证了2位相减不会出现借位。
第二行：i=(i & 0x33333333) + ((i >>> 2) & 0x33333333);i=0000 0000 0000 0000 0000 0000 0101 10000x33333333：0011 0011 0011 0011 0011 0011 0011 0011（i & 0x33333333)：4位中的低二位值：0000 0000 0000 0000 0000 0000 0001 0000((i >>> 2) & 0x33333333)：4位中的高二位值：0000 0000 0000 0000 0000 0000 0001 0010四位中的高二位和低二位相加为：0000 0000 0000 0000 0000 0000 0010 0010
第三行：i=(i + (i >>> 4)) & 0x0f0f0f0f;i=0000 0000 0000 0000 0000 0000 0010 00100x0f0f0f0f：0000 1111 0000 1111 0000 1111 0000 1111i + (i >>> 4)：原码和右移四位相加，44相加，一般值无效，0000 0000 0000 0000 0000 0000 0010 0010 +0000 0000 0000 0000 0000 0000 0000 0010=0000（无） 0000（有） 0000（无） 0000（有） 0000（无） 0000（有） 0010（无） 0100（有）(i + (i >>> 4)) & 0x0f0f0f0f：去除无效值（无效值全部变为0）：00000000 00000000 00000000 00000100
第四行：i=i + (i >>> 8);i=00000000 00000000 00000000 00000100i + (i >>> 8)：原码右移8位与原码相加（错8位相加）00000000（有） 00000000（有） 00000000（有） 00000100（有）00000000（无） 00000000（有） 00000000（有） 00000000（有）00000000（无） 00000000（有） 00000000（无） 00000100（有）i=i + (i >>> 8)： 00000000 00000000 00000000 00000100
第五行：i=i + (i >>> 16);i=00000000（无） 00000000（有） 00000000（无） 00000100（有）i + (i >>> 16): 原码右移16位与原码相加（错16位相加）00000000（无） 00000000（有） 00000000（无） 00000100（有）00000000（无） 00000000（无） 00000000（无） 00000000（有）00000000（无） 00000000（无） 00000000（无） 00000100（有）
第六行：i & 0x3f;i=00000000（无） 00000000（无） 00000000（无） 00000100（有）0x3f:0011 0000 0000 0000 0000 0011 1111i & 0x3f:最后计算的结果只有后6位二进制是有效结果：000100=4
i=1111 1111 1111 1111 1111 1111 1111 1111第一行：i=i - ((i >>> 1) & 0x55555555);i=11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 110x55555555=01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01i - ((i >>> 1) & 0x55555555):10 10 10 10 10 10 10 10
第二行：i=(i & 0x33333333) + ((i >>> 2) & 0x33333333);i=1010 1010 1010 10100x33333333：0011 0011 0011 0011 0011 0011 0011 0011（i & 0x33333333)：0010 0010 0010 0010 0010 0010 0010 0010((i >>> 2) & 0x33333333)：4位中的高二位值：0010 0010 0010 0010 0010 0010 0010 0010四位中的高二位和低二位相加为：0100 0100 0100 0100 0100 0100 0100 0100 0100
第三行：i=(i + (i >>> 4)) & 0x0f0f0f0f;i=0100 0100 0100 0100 0100 0100 0100 0100 01000x0f0f0f0f：0000 1111 0000 1111 0000 1111 0000 1111i + (i >>> 4)：原码和右移四位相加，44相加，一般值无效，0100 0100 0100 0100 0100 0100 0100 0100 0100 +0000 0100 0100 0100 0100 0100 0100 0100 0100=0000（无效） 1000 1000（无效） 1000 1000（无效） 1000 1000（无效） 1000(i + (i >>> 4)) & 0x0f0f0f0f：去除无效值（无效值全部变为0）：00001000 0001000 0001000 0001000
第四行：i=i + (i >>> 8);i=00001000 0001000 0001000 000100000001000（有） 00001000（有） 00001000（有） 00001000（有）00000000（无） 00001000（有） 00001000（有） 00001000（有）00000000（无） 00010000（有） 00010000（无） 00010000（有）i=i + (i >>> 8)：00000000（无） 00010000（有） 00010000（无效） 00010000（有）
第五行：i=i + (i >>> 16);00000000（无） 00010000（有） 00010000（无） 00010000（有）00000000（无） 00000000（无） 00000000（无） 00010000 （有）00000000（无） 00010000（无） 00010000（无） 00100000 （有）
第六行：i & 0x3f;i=00000000（无） 00010000（无） 00010000（无） 00100000 （有）0x3f:0011 0000 0000 0000 0000 0011 1111i & 0x3f:最后计算的结果只有后6位二进制是有效结果：100000=32
public static int bitCount(int i) { // HD, Figure 5-2 i=i - ((i >>> 1) & 0x55555555); i=(i & 0x33333333) + ((i >>> 2) & 0x33333333); i=(i + (i >>> 4)) & 0x0f0f0f0f; i=i + (i >>> 8); i=i + (i >>> 16); return i & 0x3f; }Integer的valueOf方法：如果缓存中有值，则读取缓存中的数字
Integer的parseInt方法：将字符串解析成Integer
Integer的decode方法： 字符串解码位数字。
valueOf和parseInt的参数必须是标准数字十进制
decode可以是各种形式的数据
System.out.println(parseInt("111"));System.out.println(parseInt("111",10));System.out.println(valueOf("111"));System.out.println(valueOf("111",10));System.out.println(valueOf(10));System.out.println(Integer.decode("100"));//十进制System.out.println(Integer.decode("0xa"));//十六进制System.out.println(Integer.decode("0Xa"));//十六进制System.out.println(Integer.decode("#a"));//十六进制System.out.println(Integer.decode("010"));//八进制System.out.println(Integer.decode("+100"));//正数System.out.println(Integer.decode("-100"));//负数 public static int parseInt(String s) throws NumberFormatException { return parseInt(s,10); } 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. */ //s不能为空，进制数在Character.MIN_RADIX（2）和Character.MAX_RADIX（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;//偏移值 int len=s.length(); int limit=-Integer.MAX_VALUE; int multmin; int digit; 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; //一个字符一个字符累加 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) { throw NumberFormatException.forInputString(s); } result *=radix; if (result < limit + digit) { throw NumberFormatException.forInputString(s); } result -=digit;//通过负数减法计算加法 } } else { throw NumberFormatException.forInputString(s); } return negative ? result : -result; } public static Integer valueOf(String s, int radix) throws NumberFormatException { return Integer.valueOf(parseInt(s,radix)); } public static Integer valueOf(String s) throws NumberFormatException { return Integer.valueOf(parseInt(s, 10)); } public static Integer valueOf(int i) { assert IntegerCache.high >=127; //判断数字是否有缓存 if (i >=IntegerCache.low && i <=IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); } public static Integer decode(String nm) throws NumberFormatException { int radix=10;//进制数 int index=0;//偏移数 boolean negative=false;//是否有符号 Integer result;//最后结果 if (nm.length()==0) throw new NumberFormatException("Zero length string"); char firstChar=nm.charAt(0); // Handle sign, if present if (firstChar=='-') { negative=true;//负数 index++; } else if (firstChar=='+') index++; // Handle radix specifier, if present if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) { index +=2; radix=16;//16进制 } else if (nm.startsWith("#", index)) { index ++; radix=16;//16进制 } else if (nm.startsWith("0", index) && nm.length() > 1 + index) { index ++; radix=8;//8进制 } if (nm.startsWith("-", index) || nm.startsWith("+", index)) throw new NumberFormatException("Sign character in wrong position"); try { result=Integer.valueOf(nm.substring(index), radix);//字符串转换成Integer result=negative ? Integer.valueOf(-result.intValue()) : result;//判断正负值 } catch (NumberFormatException e) { // If number is Integer.MIN_VALUE, we'll end up here. The next line // handles this case, and causes any genuine format error to be // rethrown. String constant=negative ? ("-" + nm.substring(index)) : nm.substring(index); result=Integer.valueOf(constant, radix); } return result; }toString(int i, int radix) 转换成指定进制的字符串
toString(int i) 转换成十进制的字符串
toHexString(int i) 转换成十六进制的字符串
toOctalString(int i) 转换成八进制的字符串
toBinaryString(int i) 转换成二进制的字符串
toUnsignedString(int i, int shift)
int转2进制：toUnsignedString（i,1）
int转8进制：toUnsignedString（i,3）
int转16进制：toUnsignedString（i,4）
public static String toString(int i, int radix) { if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) radix=10; /* Use the faster version */ if (radix==10) { return toString(i); } char buf[]=new char[33]; boolean negative=(i < 0); int charPos=32; if (!negative) { i=-i; } while (i <=-radix) { buf[charPos--]=digits[-(i % radix)]; i=i / radix; } buf[charPos]=digits[-i]; if (negative) { buf[--charPos]='-'; } return new String(buf, charPos, (33 - charPos)); } public static String toString(int i) { if (i==Integer.MIN_VALUE) return "-2147483648"; int size=(i < 0) ? stringSize(-i) + 1 : stringSize(i); char[] buf=new char[size]; getChars(i, size, buf); return new String(buf, true); } public static String toHexString(int i) { return toUnsignedString(i, 4); } public static String toOctalString(int i) { return toUnsignedString(i, 3); } public static String toBinaryString(int i) { return toUnsignedString(i, 1); } private static String toUnsignedString(int i, int shift) { char[] buf=new char[32];//int型最大为32位 int charPos=32;//数组下标位置 int radix=1 << shift;//将0001左移，shift为偏移位，如16进制则偏移4位计算，8进制偏移3位计算 int mask=radix - 1;//计算元数据的计算为，如果转16进制取后4位计算，mask为1111，与的结果为取后四位为有效位 do { buf[--charPos]=digits[i & mask]; i >>>=shift;//通过右移将计算过的位数舍弃掉，如10010100的后四位计算过了，则右移4位变成1001 } while (i !=0); //将char转换成字符串，并舍弃前面的0 return new String(buf, charPos, (32 - charPos)); }相信大家在面试的过程中可能都遇到过这样一道题吧！
public static void main(String[] args) { Integer a=1000,b=1000; Integer c=100,d=100; System.out.println(a==b); System.out.println(c==d); }相信大家得出的答案都是 false true
但是在这里我一定要说，这个答案不是绝对的 c==d 一定是true，但是a==b 却不一定就是false ，也有可能是true。
但是我得到的值是 true，true 如果不相信的同学或者抱有怀疑的同学请往下看！
我们首先要明白 通常情况下为什么答案会是 false，true。
Integer c=1000 实际在内部做了Integer c=Integer.valueOf(100)的操作。我们来看一下Integer.class的源码
/** * Returns an {@code Integer} instance representing the specified * {@code int} value. If a new {@code Integer} instance is not * required, this method should generally be used in preference to * the constructor {@link #Integer(int)}, as this method is likely * to yield significantly better space and time performance by * caching frequently requested values. * * This method will always cache values in the range -128 to 127, * inclusive, and may cache other values outside of this range. * * @param i an {@code int} value. * @return an {@code Integer} instance representing {@code i}. * @since 1.5 */ public static Integer valueOf(int i) { if (i >=IntegerCache.low && i <=IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); }从上面的代码中可以看到，当i >=IntegerCache.low && i <=IntegerCache.high的时候会从cache数组里直接取值，否则new一个新的Integer对象
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); 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) assert IntegerCache.high >=127; } private IntegerCache() {} }从上面的Integer.class源码中 可以看出，low的默认值是-128，high的值与integerCacheHighPropValue有关，
String integerCacheHighPropValue=sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");当我们未对vm中的Integercache进行设置的时候其莫认真是127，cache数组也就是从-128到127，这也就不难理解为什么
在开文时提到的经典面试题的结果会是false 和 true，之所以我后面强调不一定，就是因为当ntegerCacheHighPropValue不为null的时候取决于jvm中的设置，
在eclipse中我们可以做这样的操作：
这时候再来执行那段代码，你就会得到结果是 true和true，下次谁再问你这样的问题，可以大声的告诉他不一定，实力装13一波！
来源：blog.csdn.net/qq_36680439/article/details/78923769
上一篇：Day83
下一篇：一夜白头的诗句唯美-
发表评论