一 参考博文

二 java中的无符号数和有符号数

在计算机中，可以区分正负的类型，称为有符号类型，无正负的类型，称为无符号类型。

使用二进制中的最高位表示正负

计算机中用补码表示数值；另外，用二进制的最高位表示符号，0表示正数、1表示负数。

无符号和有符号数的范围的区别

无符号数中，所有的位都用于直接表示该值的大小；有符号数中最高位用于表示正负，所以，正值时，该数的最大值就会变小：

无符号数：1111 1111 值：255

有符号数：0111 1111 值：127

同样一个字节，无符号的最大值是255，有符号的最大值是127

三 java中的基本类型

Java的原始类型里除了char是无符号类型之外,其他都是有符号数据类型,如果需要某个宽度的无符号类型，可以用>>>进行转化，这个是java的无符号右移操作符，或者使用下一个宽度的带符号类型来模拟，

例如，需无符号的short，就用int来模拟：

int toUnsigned(short s) {

return s & 0x0FFFF;

}

java中十进制的字面常理只有一个特性，就是所有的十进制字面常量都是正数，如果想写一个负的十进制，则需要在正的十进制字面常量前面加上“-”就好了。

但是十六进制或者八进制的字面常量就不一定是正数或者负数，如果最高位是1，那么就是负数：

System.out.println(0x80);//128

//0x81看作是int型，最高位(第32位)为0，所以是正数

System.out.println(0x81);//129

System.out.println(0x8001);//32769

System.out.println(0x70000001);//1879048193

//字面量0x80000001为int型，最高位(第32位)为1，所以是负数

System.out.println(0x80000001);//-2147483647

//字面量0x80000001L强制转为long型，最高位(第64位)为0，所以是正数

System.out.println(0x80000001L);//2147483649

四 补码与真值

这里先看一个问题:

@Test

public void test01(){

System.out.println(0x80000000); // -2147483648

}

这个结果是怎么得来的?

要搞明白这个问题,得先明白几个概念:

机器数:

一个数在计算机中的二进制表示形式, 叫做这个数的机器数。机器数是带符号的，在计算机用一个数的最高位存放符号, 正数为0, 负数为1.

比如，十进制中的数 3 ，计算机字长为8位，转换成二进制就是00000011。如果是 -3 ，就是 10000011 。那么，这里的 00000011 和 10000011 就是机器数

真值:

因为第一位是符号位，所以机器数的形式值就不等于真正的数值。例如上面的有符号数 10000011，其最高位1代表负，其真正数值是 -3 而不是形式值131(10000011转换成十进制等于131)。

所以，为区别起见，将带符号位的机器数对应的真正数值称为机器数的真值(即补码表示的值)。

例：0000 0001的真值 = +000 0001 = +1，1000 0001的真值 = –000 0001 = –1

计算真值

就拿-3来说,机器数为 10000011,那么补码是 11111101,所以真值就是补码的值:

补码求值公式：补码的最高位有效位乘以(-1)，然后按一般求二进制的方法求值

例如：

-3的补码 11111101 = (-1)12^7 + 12^6+.... 12^0 = -3

3的补码 00000011 = (-1)027+........1*20= 3

0x80000000问题解析

再来看0x80000000为什么等于-2147483648,Java中用此十六进制表示int的最小值:

/**

* A constant holding the minimum value an {@code int} can

* have, -2³¹.

*/

@Native public static final int MIN_VALUE = 0x80000000;

此十六进制数内存中存储的的确是0x80000001的二进制码。因为使用十六进制给int赋值时，这里的十六进制是补码形式。

也就是说，我们给变量赋的是补码，不是源码，所以会直接把0x80000001这个补码存入内存

补码求值得: 0x80000000 = (-1)1231+.....+0*20 = -2147483648

所以这个值是这样来的!

五 java中的数据类型符号扩展

先看一个jdk源码中int转为long用到的方法:

@Test

public void test03(){

final long l = -5 & 0xffffffffL;

System.out.println(l); // 4294967291

}

如果运算一个操作数是long型，而另一个操作数是int类型。为了执行该计算，Java将int类型的数值用拓宽原生类型转换提升为long类型，然后对两个long类型数值相加。

因为int是有符号的整数类型，所以这个转换执行的是符号扩展。

-5 转换为long再转换为二进制,0xffffffff转换为二进制

进行与运算:

1111111111111111111111111111111111111111111111111111111110000101

0000000000000000000000000000000011111111111111111111111111111111

---------------------------------------------------------------------- & 与运算,两个都为1才为1,否则为0

0000000000000000000000000000000011111111111111111111111110000101= 4294967173 (十进制)

为什么-5转long前面要补1呢,这里就需要知道符号扩展规则:

窄的整型转换成较宽(字节数多)的整型时符号扩展规则：

如果最初的数值类型是有符号的，那么就执行符号扩展(即如果符号位为1，则扩展为1，如果为零，则扩展为0)；

如果它是char，那么不管它将要被提升成什么类型，都执行零扩展,

如果将一个char数值c转型为一个宽度更宽的整型，并且希望有符号扩展，那么就先将char转型为一个short，它与char上个具有同样的宽度，但是它是有符号的

宽的整型转换成窄的整型直接截取低位的值,高位扔掉

所以上面-5符号是1,所以进行符号扩展前面都补1,补成long(64位),再进行位运算得出结果!

六 Java中byte转换int时与0xff进行与运算的原因

jdk源码中byte转int用到了 & 0xff,比如String的API:

public static char charAt(byte[] value, int index) {

if (index < 0 || index >= value.length) {

throw new StringIndexOutOfBoundsException(index);

}

return (char)(value[index] & 0xff);// 先转int,再转char

}

这里为什么要用与运算呢? 因为char是无符号类型,所以不能进行符号扩展,需要零扩展,即前面补0

窄整型->宽整型要进行符号扩展,这里byte->cahr是窄到宽,如果不想进行符号扩展,则需要&0xff处理,先转int消除掉符号扩展,再转char即可

(b & 0xff)的结果是32位的int类型，前24被强制置0，后8位保持不变，然后转换成char型时，直接截取后16位。这样不管b是正数还是负数，转换成char时，都相当于是在左边补上8个0，即进行零扩展而不是符号扩展

至于为什么要进行零扩展: 因为char是无符号类型,他会把 1111 1111 当做65535而不是-1,,所以你前面补1的话数就会变很大,所以这里需要进行0扩展,于是 & 0xff这种骚操作就来了,这里确实有点绕!如果不看源码(并且要认真看啊,哈哈)一般发现不了这种问题

再比如下面代码:

@Test

public void test01(){

byte b=-1;

System.out.println((int)b); // -1

System.out.println(b & 0xff); // 255

}

这里第二行255应该都好说,高位清零就是,至于直接强转为-1,那么符号扩展之后补码为11111111111111111111111111111111,求出结果原码:100000000000000000000000000001 还是-1,所以就是上面的结果,原理就是这样!

主要就是一个符号扩展延伸出来的问题!