计算机位运算操作符

 

 

大致分为其中：按位或（I） 按位与( &)    按位异或(^)   按位取反(~)  左移(<<)  右移(>>)   无符号右移(>>>)

 

 

按位或（I）

 

有1则为1，无1则为0

• 1 | 0 = 1 
• 1 | 1 = 1
• 0 | 0 = 0

按位与( &) 

 

 

 两个数都为1，则为1，否则为0

 

• 1 | 0 = 0
• 1 | 1 = 1
• 0 | 0 = 0

按位异或(^)

 

相同位不同则为1，相同则为0。

 

• 1 | 0 = 1
• 1 | 1 = 0
• 0 | 0 = 0

 

按位取反(~)

 

为单目运算，是针对数字本身进行按位取反，1变0，0变1

 

• 1 = 0
• 0 = 1

 

左移(<<)

 

是将一个二进制数，全部向左平移X位

 

eg: 将0X23（十六进制数）左移两位

 

 0X23 = 0010 0011  左移两位就是  1000 1100 。（左移之后右边空出来的位置，全部补零，左边移出的部分忽略）

 

右移(>>)  

 

和上面的左移刚好相反，（规则是向右移动X位，右边移出的部分忽略，左边空出来的位置，全部补零）

 

 

 

无符号右移(>>>)

 

 

 无符号右移，忽略符号位，空位都以0补齐

 

 

机器数(最高位为符号位，0为正，1为负)：

如：5 机器数为   0000 0101;         -5机器数为  1000  0101

 

 

原码：和机器数一样。

 

 

反码：

正数：和原码一样

负数：除符号位以外，其余位都按位取反。

 

补码：

正数：和原码一样

负数：除符号位以外，在反码的基础上，加1

 

 

 注意：在使用时，机器都是使用补码进行表示的。

 

 

 

 

 

 

 

原码：

正数的原码是

 

原码、反码、补码的概念：

 

http://www.cnblogs.com/zhangziqiu/archive/2011/03/30/ComputerCode.html

 

 

重要须知：java虚拟机在表示整数的时候(java都是有符号数，没有无符号的概念)，使用补码来进行表示；浮点数使用的是IEEE 754 标准(IEEE 二进制浮点数算术标准)；字符串都用的是Unicode字符集和UTF-8编码。 

 

 

 -------------------------------------下面为自己理解---------------------------------------------------------------------------

 

大端(big endian):低地址存放高有效字节

小端(little endian):低地址存放低有效字节

 

通用原则：低索引位存储的是低位值，高索引位存储的是高位值？？？？？？是否正确

java采用的大端【低内存地址-->高内存地址，高位字节排列在低内存地址，所以数据在内存地址排列是如下的格式(byte[3],byte[2],byte[1]，byte[0])，刚好是数据的大小顺序】

现在主流的CPU,intel系列的是采用的little endian的格式存放数据。网络编程中,TCP/IP统一采用大端方式传送数据，所以有时我们也会把大端方式称之为网络字节序

 

 

注意：

int之类的，低字节位数存放的是低位数据，高字节位数存放的是高位数据。

如

int a = 12; 

十六进制表示为： 00 00 00 0C

二进制表示为： 00000000 00000000 00000000 00001100

需要四个字节表示int类型，byte[0],byte[1],byte[2],byte[3]

存放规则：

byte[0] = 00001100  

byte[1] = 00000000

byte[2] = 00000000

byte[3] = 00000000

 

 

int b = 5123

十六进制表示为  0x00 00 14 03

二进制标示为：00000000 00000000 00010100 00000011

需要四个字节表示int类型，byte[0],byte[1],byte[2],byte[3]

存放规则：

byte[0] = 00000011

byte[1] = 00010100 

byte[2] = 00000000 

byte[3] = 00000000 

 

移位操作只是为了将目标byte[]移动到最低位，然后强转为byte,并赋值给对应的byte[]

 

大端小端只是指这个字节是按照从小到大、还是从大到小这样的顺序排列

 

 

 

 

 long/int <-->  byte[]

 

    public static byte[] getBytes(int data) {
        byte[] bytes = new byte[4];
        bytes[0] = (byte) (0XFF & data);
        bytes[1] = (byte) ((0XFF00 & data) >> 8);
        bytes[2] = (byte) ((0XFF0000 & data) >> 16);
        bytes[3] = (byte) ((0XFF000000 & data) >> 24);
        return bytes;
    }

    public static int getInt(byte[] bytes) {
        return (0XFF & bytes[0]) | (0XFF00 & (bytes[1] << 8)) | (0XFF0000 & (bytes[2] << 16)) | (0XFF000000 & (bytes[3] << 24));
    }

    public static byte[] getBytes(long data) {
        byte[] bytes = new byte[8];
        bytes[0] = (byte) (data & 0xff);
        bytes[1] = (byte) ((data >> 8) & 0xff);
        bytes[2] = (byte) ((data >> 16) & 0xff);
        bytes[3] = (byte) ((data >> 24) & 0xff);
        bytes[4] = (byte) ((data >> 32) & 0xff);
        bytes[5] = (byte) ((data >> 40) & 0xff);
        bytes[6] = (byte) ((data >> 48) & 0xff);
        bytes[7] = (byte) ((data >> 56) & 0xff);
        return bytes;
    }


    public static long getLong(byte[] bytes) {
        return (0xffL & (long) bytes[0]) | (0xff00L & ((long) bytes[1] << 8)) | (0xff0000L & ((long) bytes[2] << 16)) | (0xff000000L & ((long) bytes[3] << 24))
                | (0xff00000000L & ((long) bytes[4] << 32)) | (0xff0000000000L & ((long) bytes[5] << 40)) | (0xff000000000000L & ((long) bytes[6] << 48)) | (0xff00000000000000L & ((long) bytes[7] << 56));
    }

    public static byte[] getBytes(double data) {
        long l = Double.doubleToLongBits(data);
        return getBytes(l);
    }

    public static double getDouble(byte[] data) {
        long l = getLong(data);
        return Double.longBitsToDouble(l);
    }

 

 

下面是Netty源码的写法:

    /**
     * 大端: 低位放高位地址
     * &(与): 1 & 1=1; 1&0 =0   用1可以保证对应位置不变
     * |(或): 0 | 0=0; 0|1=1  用0可以保证对应位置不变
     * >> / << / >>>  左右移动N位
     */
    public static byte[] setInt(int value) {
        byte[] memory = new byte[4];
        memory[0] = (byte) (value >>> 24);
        memory[1] = (byte) (value >>> 16);
        memory[2] = (byte) (value >>> 8);
        memory[3] = (byte) value;
        return memory;
    }


    public static int getInt(byte[] memory) {
        return (memory[0] & 0xff) << 24 |
                (memory[1] & 0xff) << 16 |
                (memory[2] & 0xff) << 8 |
                memory[3] & 0xff;
    }