二进制操作

二进制运算

八位	七位	六位	五位	四位	三位	二位	一位
1	1	1	1	1	1	1	1
128	64	32	16	8	4	2	1

• 按位与&

  1.两个二进制值的同一位置上都为1，结果位上的值才为1.

  例如 51 & 5 = 1

        0011 0011
    & 0000 0101
    ----------------------
        0000 0001 // 结果则为1
  

  2.特殊用法

  1.清零

  2.取一个数的指定位

  // 清零
        0011 0110 // 任意数
    & 0000 0000
    ----------------------
      0000 0000 // 结果都为0
    
  // 取任意位(取几位 则为几个1)
        0110 0011 //
    &   0000 1111 // 取后四位
    ---------------------------
      0000 0011
        
  

• 按位或|

  1.两个二进制值的同一位置有一个位1，结果则为1.

  例如 51 | 5 = 7

        0011 0011
    |   0000 0101
    ------------
        0011 0111 // 结果为7
  

  2.用法

  用法其实就是将指定位置的数置位一

        0010 1000
    | 1111 1111
    ---------------
      1111 1111 // 将所有位都置为1
  

• 异或^

  1.两个二进制的同一位置值不同，则该结果为1，否则为0.

    0^0=0 --- 0^1=1 --- 1^1=0
    0011 0011 // 51
  ^ 0000 0101 // 5
  -------------------
    0011 0110 //  0  2 4 0 16 32 = 54
  

  2.用法

  1). 与1相与或 使指定位置翻转
  2). 与0相与或 保留原值

    0011 0011                                               
  ^ 0000 1111 // 高四位保留原值 低四位值翻转
  ------------
    0011 1100
  

  3).两个变量交换值，例如交互A与B的值

    0000 0100 // A = 4
  ^ 0000 0011 // B = 3
  ---------------------
    0000 0111 // A = A^B
  ^ 0000 0011 // B = 3
  ----------------------
    0000 0100 // B = A^B(A值为新值)
  ^ 0000 0111 // 
  ----------------------
    0000 0011 // A = A^B(A/B值为新值) 转换完成
  

取反与运算~

• 对一个二进制数按位取反，即0变1，1变0

左移<<

• 将参与运算的二进制数据全部左移若干位，右边补零。

  2(0000 0010) << 1 = 4(0000 0100);
  10(0000 0101) << 1 = 20(0001 0100)
  

• 若左移时舍弃的高位不包含1，则左移一位，相当于乘以2.

右移>>

• 将参与运算的二进制数据全部右移若干位，正数左补0，负数左补1.

• 若右移时舍弃的高位不是，则右移一位，相当于除以2.

  4（0000 0100） >> 1 = 2(0000 0010)
  20(0001 0100) >> 1 = 10(0000 1010)
  

无符号右移运算>>>

• 将参与运算的二进制数据全部右移若干位，右移后左边用0补齐。

            -14（11111111 11111111 11111111 11110010）
  >>>       2
  ------------------------------------------------
            1073741820 (00111111 11111111 11111111 11111100)
  

• 负数的二进制表示 32个1表示-1，与正数表示不太一样，负数以其正数的补码形式表示

原码、反码、补码

• 正数的原码、反码、补码都是其本身
• 负数的绝对值取反，得反码再+1得补码，以补码显示(以加法的方式做减法)
• 原码一个正数按照绝对值大小转换成的二进制成为原码

8位的情况下，如果8-3其实就等于8+5，因为5是3的补码（补码是通过反码+1得到的），8+(-3)=8+5,所以（-3）= 5，

4bit
-3 原 1011 反 1100 补 1101
-1 原 1001 反 1110 补 1111
-3 + -1 == 1101 + 1111 == 1 1100 == 1100补
1100补 == 1011反 == 1100原 == -4


3bit
-3 原 111 反 100 补 101
-1 原 101 反 110 补 111
-3 + -1 == 101 + 111 == 1 100 == 100(补)
100补 == 111反 == 100原 == -0 == -4

代码案例

public class LeftMoveDemo {

    public static void main(String[] args) {

        byte[] a = new byte[10];
        /**
         * 原码 11111111
         * 反码 10000000
         * 补码 10000001
         */
        a[0] = -127;
        /**
         * 原码 10000000
         * 反码 11111111
         * 补码 10000000
         */
        a[1] = -128;
        System.out.println(a[0]);// -127
        int c = a[0] & 0xFF;
        /**
         * 运算前 byte会转为int
         *      11111111 11111111 11111111 10000001
         *  &   00000000 00000000 00000000 11111111
         *  -----------------------------------------
         *      00000000 00000000 00000000 10000001(129)
         */
        System.out.println(c); // 129
        /**
         * 运算前 byte会转为int
         *              11111111 11111111 11111111 10000001
         *         <<   11111111 11111111 11111111 00000010
         *  强转为byte，丢失高24位 00000010 = 2
         *  
         */
        a[2] = (byte) (a[0]<<1);
        System.out.println(a[2]);
        /**
         * 运算前 byte会转为int
         *                 11111111 11111111 11111111 10000001
         *         >>   11111111 11111111 11111111 11000000
         *  强转为byte，丢失高24位 11000001 = -64
         *
         */
        a[3] = (byte) (a[0]>>1);
        System.out.println(a[3]);

    }

        // 纯案例
    private String changeHex(byte[] bs){
        char[] hexArray = "0123456789abcdef".toCharArray(); // 将字符串转换为一个字符数组
        char[] hexChars = new char[bs.length * 2]; // 创建一个bs字符数组两倍的字符数组
        for ( int j = 0; j < bs.length; j++ ) {
            // 保持二进制补码的一致性 因为byte类型字符是8bit的
            // 而int为32bit 会自动补齐高位1  所以与上0xFF之后可以保持高位一致性
            // 当byte要转化为int的时候，高的24位必然会补1，
            // 这样，其二进制补码其实已经不一致了，
            // &0xff可以将高的24位置为0，低8位保持原样，
            // 这样做的目的就是为了保证二进制数据的一致性。
            int v = bs[j] & 0xFF;
            hexChars[j * 2] = hexArray[v >>> 4];
            hexChars[j * 2 + 1] = hexArray[v & 0x0F];
        }

        return "";
    }

}