您的位置:首页 > 编程语言 > Java开发

【jdk1.8】Integer源码分析

2016-03-24 10:34 741 查看
先看下Integer的类声明:

public final class Integer extends Number implements Comparable<Integer>


同样地,Integer是一个不变类,实现了Comparable接口,继承了Number类(见下图)。



除此之外,Integer类还有三点需要说的。

1. 静态内部类IntegerCache

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);
/**要比127大*/
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;
/**将[low, high]区间的值缓存起来,默认缓存区间[-128, 127]*/
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 i1 = 127;
Integer i2 = 127;
Integer i3 = 128;
Integer i4 = 128;
Integer i5 = Integer.valueOf(127);
System.out.println(i1 == i2);
System.out.println(i3 == i4);
System.out.println(i1 == i5);


输出:

true
false
true


也就是说i1,i2与i5都使用的是缓存的Integer对象,而i3和i4使用的是新创建的Integer对象。请看
Integer valueOf(int i)
方法:

public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}


2. int parseInt(String s, int radix) 和 String toString(int i, int radix)

首先,一看参数名就知道可以进行进制转换。其次,radix的范围只能是[2, 36]。36即10个数字加26个字母,不区分大小写。

然后对于parseInt方法来说,一看返回类型是int,也就意味着所处理的数字大小只能在int范围内,即[-2147483648, 2147483647]。超出范围就会抛出异常
java.lang.NumberFormatException


使用这两个函数就可以将一个数字从任意进制[2, 36]转到另一进制。当然以int为桥梁,自然也会受到int范围的限制。

请看:

String unknown = "7fffffff";
int temp;
System.out.println((temp=Integer.parseInt(unknown, 16)));
System.out.println(Integer.toString(temp, 2));


输出结果:

2147483647
1111111111111111111111111111111


unknown = "-80000000"
时,

-2147483648
-10000000000000000000000000000000


注意此处必须添符号,否则就会当成正数而越界。

3. 一些其他有趣的方法

int a = 10;
System.out.println("original number:\t"+ a);
System.out.println("lowestOneBit:\t" + Integer.lowestOneBit(a));//最低一位是1的数
System.out.println("toBinaryString:\t" + Integer.toBinaryString(a));
System.out.println("highestOneBit:\t" + Integer.highestOneBit(a));//最高一位是1的数
System.out.println("numberOfLeadingZeros:\t" + Integer.numberOfLeadingZeros(a));
System.out.println("numberOfTrailingZeros:\t" + Integer.numberOfTrailingZeros(a));
System.out.println("bitCount:\t" + Integer.bitCount(a));//二进制中1的个数
System.out.println("rotateLeft:\t" + Integer.toBinaryString(Integer.rotateLeft(a, 3)));//旋转,都是针对二进制字符串来做的
System.out.println("rotateRight:\t" + Integer.toBinaryString(Integer.rotateRight(a, 4)));
System.out.println("reverse:\t" + Integer.toBinaryString(Integer.reverse(a)));
System.out.println("reverseBytes:\t" + Integer.toBinaryString(Integer.reverseBytes(a)));
System.out.println("signum:\t" + Integer.signum(a));//符号,正负或零


结果

original number:    10
lowestOneBit:   2
toBinaryString: 1010
highestOneBit:  8
numberOfLeadingZeros:   28
numberOfTrailingZeros:  1
bitCount:   2
rotateLeft: 1010000
rotateRight:    10100000000000000000000000000000
reverse:    1010000000000000000000000000000
reverseBytes:   1010000000000000000000000000
signum: 1
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: