Java千百问_06数据结构（024）_用二进制如何表示整型数值

点击进入_更多_Java千百问

1、用二进制如何表示整型数值

我们都知道，计算机只认识0、1二进制，我们一般操作的寄存器和存储单元也都只认识二进制，我们称一个二进制为一个bit（位），一般32位计算机的寄存器允许操作32bit的数据，即32个0或1，由于书写过长，我们一般使用十六进制表示（每两个十六进制成为一个byte字节，即8bit=1byte）。例如：

1111 1111 1111 1111 1111 1111 1111 1111 = ffffffff

了解32位和64位计算机看这里：32位和64位计算机有什么区别

Java中也是一样，以上整型数值最终都会被解释为二进制机器码，具体规则如下：

1. 首位均是符号位，1代表负，0代表正。

2. 正值的二进制补码，即对应的负值。

3. 不同类型的范围均是-2^(n-1)到2^(n-1)-1，其中n为类型所占用的bit数。

其中所提到的补码，即反码+1，反码也就是对原码的每一个二进制位取反，以长度8bit整型为例：

原码：0100 1010

反码：1011 0101

补码：1011 0110

2、Java中整型如何用二进制表示

在Java语言中，整型数值分为4种：byte、short、int、long，均是带符号整型。

了解基本数据类型看这里：java有哪8种基本数据类型
这些基本类型除了长度不一致外，其他规则均按照以上规则，具体如下：

byte
内存中占用1个字节，8bit。由于是带符号数值，所以只能使用7bit的二进制来表示大小，最大只能表示111 1111，最小即它的补码1000 0000，所以他的范围是：

1 000 0000 到 0 111 1111

其中，首位符号位，1代表负，0代表正，故转换为10进制即-128到127。

例如：

public class Test {

    public static void main(String[] args) throws UnsupportedEncodingException {
        byte b1 = 100;
        byte b2 = -100;

        System.out.println("正byte===" + Integer.toBinaryString(b1));// 转二进制
        System.out.println("负byte===" + Integer.toBinaryString(b2));
        System.out.println("正byte===" + Integer.toHexString(b1));// 转十六进制
        System.out.println("负byte===" + Integer.toHexString(b2));
?}
}

结果如下：
正byte===1111111
负byte===11111111111111111111111110000000
正byte===7f
负byte===ffffff80

这里我们看到，byte通过Integer类的工具转为二进制拥有32bit长度，实际上在java中，byte和short都是通过int进行赋值操作，正值会在前端补零，但真正压入栈或作为对象的属性存入堆时，只会占用对应长度：byte占用8bit，short占用16bit。例如：

byte b = 0x81;//编译错误
byte b = 0xffffff81;//正确

了解byte、short到内存占用看这里：[byte、short到底占用多少内存][4]

short
内存中占用2个字节，16bit。同byte，带符号数值，使用15bit的二进制来表示大小，最大只能表示111 1111 1111 1111，最小即它的补码1000 0000 0000 0000，所以他的范围是：

1 000 0000 0000 0000 到 0 111 1111 1111 1111

其中，首位符号位，1代表负，0代表正，故转换为10进制即-32768到32767。

例如：

public class Test {

    public static void main(String[] args) throws UnsupportedEncodingException {
        short s1 = 23235;
        short s2 = -23235;

        System.out.println("正short===" + Integer.toBinaryString(s1));// 转二进制
        System.out.println("负short===" + Integer.toBinaryString(s2));
        System.out.println("正short===" + Integer.toHexString(s1));// 转十六进制
        System.out.println("负short===" + Integer.toHexString(s2));
?}
}

结果如下：
正short===101101011000011
负short===11111111111111111010010100111101
正short===5ac3
负short===ffffa53d

同样，在java中short只能通过int进行赋值。

int
内存中占用4个字节，32bit。带符号数值，使用31bit的二进制来表示大小，规则同上，他的范围是：

1 000 0000 0000 0000 0000 0000 0000 0000 到 0 111 1111 1111 1111 1111 1111 1111 1111

其中，首位符号位，1代表负，0代表正，故转换为10进制即-2,147,483,648到2,147,483,648。

例如：

public class Test {

    public static void main(String[] args) throws UnsupportedEncodingException {
        int i1 = 328999123;
        int i2 = -328999123;

        System.out.println("正int===" + Integer.toBinaryString(i1));// 转二进制
        System.out.println("负int===" + Integer.toBinaryString(i2));
        System.out.println("正int===" + Integer.toHexString(i1));// 转十六进制
        System.out.println("负int===" + Integer.toHexString(i2));
?}
}

结果如下：

正int===10011100111000010000011010011
负int===11101100011000111101111100101101
正int===139c20d3
负int===ec63df2d

long
内存中占用8个字节，64bit。带符号数值，使用63bit的二进制来表示大小，规则同上，他的范围是：

1 000 0000 0000 0000 0000 0000 0000 0000 到 0 111 1111 1111 1111 1111 1111 1111 1111

其中，首位符号位，1代表负，0代表正，故转换为10进制即-2,147,483,648到2,147,483,648。

例如：

public class Test {

    public static void main(String[] args) throws UnsupportedEncodingException {
        int i1 = 328999123;
        int i2 = -328999123;

        System.out.println("正int===" + Integer.toBinaryString(i1));// 转二进制
        System.out.println("负int===" + Integer.toBinaryString(i2));
        System.out.println("正int===" + Integer.toHexString(i1));// 转十六进制
        System.out.println("负int===" + Integer.toHexString(i2));
?}
}

结果如下：

正int===10011100111000010000011010011
负int===11101100011000111101111100101101
正int===139c20d3
负int===ec63df2d

这里要说的是，对于32位机，由于寄存器指令只能接受32bit的值，所以64bit的long在进行运算时只能分段处理，性能相对较慢。所以在32位机最好不要使用long和double等64bit的类型。而64位计算机可以完美使用。