初步了解位运算

    public static void function1(int n) {
        System.out.println("十转2 8 16");
        //  java进制转换
//        java中进行二进制，八进制，十六进制，十进制间进行相互转换
//        十进制转成十六进制：
        System.out.println(Integer.toHexString(n));
//        十进制转成八进制
        System.out.println(Integer.toOctalString(n));
//        十进制转成二进制
        System.out.println(Integer.toBinaryString(n));
    }

    public static StringBuffer ten(int n) {
//        自己算 十转二
        StringBuffer sb = new StringBuffer();
        int res = 0;
        while (n > 0) {
            res = n % 2; //除2 取余数作为二进制数
            sb.append(res);
            n = n / 2;
        }
        return sb;

    }
public static int two(int bi) {
    //        自己算 二转十
    StringBuffer sb = new StringBuffer().append(bi).reverse();
    int sum = 0;
    int len = sb.length();
    for (int i = 0; i < len; i++) {
        //第i位 的数字为：
        int dt = Integer.parseInt(sb.charAt(i) + "");
        sum += Math.pow(2, i) * dt;
    }
    return sum;
}
从右往左

位运算

  int newCapacity = 10 + (10 >> 1);

10000001  左为高  右为低

    int  4个字节byte  32bit位

数字1 转换成 2 进制  以两对4位数呈现 或者以4对4位数呈现 以及8对四位数呈现

 0000 0001   32位

521    10进制

1*10的0次方 =1

2*10的1次方 =20

5*10的2次方 =500

 0000 0101   2对应的2进制

1*2的0次方 =1

0*2的1次方 =0

1*2的2次方 =4

 1+0+4=5

1G=1024MB 计算机在运行时

1G=1000MB 厂家的运算

0101 0101    2进制

原码   ===》我们看到的 源码是我们所看到的计算机高级语言

反码

补码   ===》真正运行的 计算机语言只认识01的补码

01.正数的原码，反码，补码都一致（正数没有补码 因为他的补码就是他的源码）

02.java中所有的数字都是有符号的  符号位 正数0  负数1（最高位 为8位数）

03.负数的反码=符号位不变+其他位取反（1变0 0变1）

04. 每对的最左边叫最高位 每对的最右边是最低位

05.负数的补码=反码+1

例子： 1-2

 先把1转换成2进制

 0 0 0 0 0 0 0 1

 把-2转换成2进制

 1 0 0 0 0 0 1 0    -2的源码

 1 1 1 1 1 1 0 1    -2的反码

 1 1 1 1 1 1 1 0    -2的补码

   0 0 0 0 0 0 0 1   1的补码

+  1 1 1 1 1 1 1 0

============================

   1 1 1 1 1 1 1 1    结果的补码

   1 1 1 1 1 1 1 0    结果的反码

   1 0 0 0 0 0 0 1    结果的原码   -1      

例子： 4-3   

 先把4转换成2进制

 0 0 0 0 0 1 0 0

 把-3转换成2进制

 1 0 0 0 0 0 1 1   -3的源码

 1 1 1 1 1 1 0 0   -3的反码

 1 1 1 1 1 1 0 1   -3的补码

+0 0 0 0 0 1 0 0

==========================

 0 0 0 0 0 0 0 1  结果的补码

算术右移

int newCapacity = 10 + (10 >> 1);

先算出10的2进制

0 0 0 0 1 0 1 0

  0 0 0 0 1 0 1 0    符号位不变，低位溢出删除，高位补零！

==========================================

0 0 0 0 0 1 0 1

算术左移

10 << 1

   先算出10的2进制

   0 0 0 0 1 0 1 0

 0 0 0 0 1 0 1 0     符号位不变，高位溢出删除，低位补零！

 ==============================

   0 0 0 1 0 1 0 0    20

怎么以最快的速度从2 变成 8

    先算出2的2进制

    0 0 0 0 0 0 1 0

0 0 0 0 0 0 1 0     2<<2

============================

    0 0 0 0 1 0 0 0    8

逻辑右移：不管符号位！低位溢出删除，高位补零！

10>>>2

    先算出10的2进制

    0 0 0 0 1 0 1 0&

        0 0 0 0 1 0 1 0

=======================

    0 0 0 0 0 0 1 0

-1

  1 0 0 0 0 0 0 1  原码

  1 1 1 1 1 1 1 0  反码

  1 1 1 1 1 1 1 1  补码   >>>1

    1 1 1 1 1 1 1 1

========================

  0 1 1 1 1 1 1 1

&& || ！   逻辑与或非   短路与或非  返回的都是boolean类型的值

位运算： 

按位与 &   两位都为1，结果为1

  3&4

  0 0 0 0 0 0 1 1

& 0 0 0 0 0 1 0 0

===========================

  0 0 0 0 0 0 0 0

  

  

按位或 |   两位有一位为1，结果为1

  3|2

  0 0 0 0 0 0 1 1

| 0 0 0 0 0 0 1 0

===========================

  0 0 0 0 0 0 1 1

按位异或 ^   必须是一位是0，一位是1，结果才为1

  3^4

  0 0 0 0 0 0 1 1

^ 0 0 0 0 0 1 0 0

===========================

  0 0 0 0 0 1 1 1

按位取反 ~  : 就是数值+1之后取相反的值

 ~3

~  0 0 0 0 0 0 1 1

=========================

   1 1 1 1 1 1 0 0    负数

   1 0 0 0 0 0 1 1    反码

   1 0 0 0 0 1 0 0

        System.out.println(2 >> 1); //算术右移
        /*
         *   0000 0010  2
         *    0000 0010   2
         * _________________________
         *   0000 0001    1
         * */
        System.out.println(2 << 1);//算术左移
        /*
         *   0000 0010  2
         *  0000 0010   2
         * _________________________
         *   0000 0100    4
         * */
        System.out.println(2 >>> 1);//逻辑右移
        /*
         *   0000 0010  2
         *    0000 0010   2
         * _________________________
         *   0000 0001    1
         * */
        System.out.println(2 | 1);
        /*
         *   0000 0010  2
         *   0000 0001  1
         * _________________________
         *   0000 0011  3
         * */
        System.out.println(2 & 1);
        /*
         *   0000 0010  2
         *   0000 0001  1
         * _________________________
         *   0000 0000 0
         * */
        System.out.println(~2);
        /*
         *   0000 0010  2  源码
         *   1000 0010  2  负数
         *   1111 1101  3  反码
         * */
        System.out.println(2 - 1);
        /*
         *   1000 0001   -1 源码
         *   1111 1110   -1 反码
         *   1111 1111   -1 补码
         *
         *   0000 0010   2 源码
         * + 1111 1111  -1 补码
         *  ------------------------
         *   0000 0001  1的源码
         * */
        System.out.println(1 - 2);
        /*
         *   1 0 0 0 0 0 1 0    -2的源码
         *   1 1 1 1 1 1 0 1    -2的反码
         *   1 1 1 1 1 1 1 0    -2的补码
         *   0 0 0 0 0 0 0 1     1的补码
         * + 1 1 1 1 1 1 1 0
         *  ----------------------
         *   1 1 1 1 1 1 1 1    -1结果的补码
         *   1 1 1 1 1 1 1 0    -1结果的反码
         *   1 0 0 0 0 0 0 1    -1结果的原码   -
         * */