计算机数值表示Integer

计算机数值表示&Integer

原码反码补码
- 为什么在计算机中使用补码
- 将减法转换为加法的正确性证明
Integer
Short，Long,Byte
Double，Float

原文章计算机数值表示&Integer

在分析Integer类之前，先复习一下在计算机中数值的表示

原码反码补码

有符号数在计算机中存储，用数的最高位存放符号, 正数为0, 负数为1

原码：原码就是符号位加上真值的绝对值，即用第一个二进制位表示符号（正数该位为0，负数该位为1），其余位表示值。
反码：正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
补码：正数的补码就是其本身；负数的补码是在其反码的基础上+1
例如：
2 : 00000010（原码），00000010（反码），00000010（补码）
-2: 10000010（原码），11111101（反码），11111110（补码）

由补码求源码：

如果补码的符号位为“0”，表示是一个正数，所以补码就是该数的原码。
如果补码的符号位为“1”，表示是一个负数，求原码的操作可以是：符号位为1，其余各位取反，然后再整个数加1。

为什么在计算机中使用补码

对于计算机而言，加减乘数是最基础的运算, 要设计的尽量简单。我们知道，根据运算法则，减去一个正数等于加上一个负数，所以计算机内部可以只有加法而没有减法，将符号位也参与运算，将减法用加法替代。

补码的优点：

可将减法变为加法，省去减法器；
修复了原码中0的符号(有 [+0] [-0] 之分)以及存在两个编码(0000 0000 和 1000 0000)的问题，而且还能够多表示一个最低数。

补码的由来
负数的补码时相应的正数取反+1
假如一个数是10000110，对应的正数是00000110,该数的补码是：11111010
可以看做是0-num

100000000
-00000110
-----------11111010

1 0000 0000 = 1111 1111 + 1
因此可以将以上分为两个步骤：按位取反，加1

 11111111
-00000110
-------------11111001  +111111010

将减法转换为加法的正确性证明

已知：X、Y都为正整数，Z = X - Y = X + (-Y)
证明：Z = X的补码 + (-Y的补码)

X的补码 = X; // 正数的补码为其自身
-Y的补码 = (1111 1111 - Y) + 1; // 负数的补码为除符号位的其它位取反加1
Z = X的补码 + (-Y的补码) = X +  (1111 1111 - Y) + 1 = X - Y + 1 0000 0000= X - Y + 0000 0000= X - Y

Integer

佩服Lee Boynton，Arthur van Hoff，Josh Bloch，Joseph D. Darcy

计算机中二进制运算比普通的加减乘除快很多，因此代码中很多使用了位运算，难以阅读，挑选了几个具有代表性的函数分析

2^n-1 是一个神奇的数，在各种场景中都有它的身影，比如hashmap取索引，比如求2^n的mod

Integer具有缓存机制，当然不止是Integer,包括Long，Byte等都具有这种性质

public final class Integer extends Number implements Comparable<Integer> {@Native public static final int   MIN_VALUE = 0x80000000;@Native public static final int   MAX_VALUE = 0x7fffffff;public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");private final int value;

MIN_VALUE表示最小值-2^31 ，MAX_VALUE表示最大值2^32-1

转换进制


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);}//int型的数最长32位，加上符号33位char buf[] = new char[33];boolean negative = (i < 0);int charPos = 32;//将所有的数转换为负数，主要是为了统一接下来的计算//如果不这样，负数%radix为负数，正数%radix为正数，需要分两种情况判断//为什么不转换为正数，因为最小的负数-2^31转换为正数会溢出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));}

转换为无符号进制数,转换为2^shift进制

private static String toUnsignedString0(int val, int shift) {// assert shift > 0 && shift <=5 : "Illegal shift value";//得到除了前导0其他的位数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);// Use special constructor which takes over "buf".return new String(buf, true);}static int formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {int charPos = len;//要转换的进制int radix = 1 << shift;//掩码，永远时2^n-1int mask = radix - 1;//每次得到后shift位，val & mask相当于mod运算！，循环得到结果do {buf[offset + --charPos] = Integer.digits[val & mask];val >>>= shift;} while (val != 0 && charPos > 0);return charPos;}

将一个整数放入字符数值中

static void getChars(int i, int index, char[] buf) {int q, r;int charPos = index;char sign = 0;if (i < 0) {sign = '-';i = -i;}// Generate two digits per iterationwhile (i >= 65536) {q = i / 100;// really: r = i - (q * 100);r = i - ((q << 6) + (q << 5) + (q << 2));i = q;//实际上r是一个100以内的数，一次性可以确定两位，根据DigitOnes和DigitTens两个数组buf [--charPos] = DigitOnes[r];buf [--charPos] = DigitTens[r];}// Fall thru to fast mode for smaller numbers// assert(i <= 65536, i);for (;;) {q = (i * 52429) >>> (16+3);r = i - ((q << 3) + (q << 1));  // r = i-(q*10) ...buf [--charPos] = digits [r];i = q;if (i == 0) break;}if (sign != 0) {buf [--charPos] = sign;}}

求前导0的数量

public static int numberOfLeadingZeros(int i) {// HD, Figure 5-6if (i == 0)return 32;int n = 1;//先判断高16位，再判断8位...类似二分法if (i >>> 16 == 0) { n += 16; i <<= 16; }if (i >>> 24 == 0) { n +=  8; i <<=  8; }if (i >>> 28 == 0) { n +=  4; i <<=  4; }if (i >>> 30 == 0) { n +=  2; i <<=  2; }//判断最高位，若是0，则就是31位，反之30位前导0n -= i >>> 31;return n;}

求低位第一位为1的值

public static int lowestOneBit(int i) {// HD, Section 2-1return i & -i;}

求高为第一位为1的权值

public static int highestOneBit(int i) {// HD, Figure 3-1i |= (i >>  1);i |= (i >>  2);i |= (i >>  4);i |= (i >>  8);i |= (i >> 16);//此时i为11111111...return i - (i >>> 1);}

缓存机制：默认缓存范围是-128～127，因此，两个数值在此区间的Ing=teger使用==判断返回的是true，二其他相等范围的Integer则返回false。例如：

        Integer c=55;Integer d=55;System.out.println(c==d);(true)Integer e=999;Integer f=999;System.out.println(e==f);(false)

源码：

//私有的静态内部类
private static class IntegerCache {static final int low = -128;static final int high;//使用一个数组存储缓存static final Integer cache[];//静态代码块，在类加载时期就已经执行了static {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_VALUEh = 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++);assert IntegerCache.high >= 127;}private IntegerCache() {}}
//如果数值在缓存范围，获取的就是缓存的对象，而非重新new
public static Integer valueOf(int i) {if (i >= IntegerCache.low && i <= IntegerCache.high)return IntegerCache.cache[i + (-IntegerCache.low)];return new Integer(i);}

Short，Long,Byte

这些类与Integer相似，只是范围不同，它们也有缓存机制，范围都是-128～127，并且不可更改

Double，Float

注意：是允许1/0,-1/0,0/0的,其他类型都不允许

例如：

        Double a=-1.0/0.0+100;Double b=1.0/0.0;Double c=0.0/0.0;System.out.println(a);  ( -Infinity )System.out.println(b);  ( Infinity )System.out.println(c);  ( NaN )

借鉴了你真的了解补码吗