JAVA 二进制常用方式

九友九

于 2024-08-08 10:42:15 发布

阅读量206

点赞数 6

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_44275684/article/details/141020674

版权

与（&）：检查某个位是否被设置。例如，如果你有一个表示权限的整数，并且你想检查某个特定的权限是否被赋予，你可以使用与操作。
或（|）：设置某个位。这通常用于添加权限或设置标志。
异或（^）：切换某个位。这在某些算法中很有用，比如在不使用额外存储空间的情况下交换两个变量的值。
非（~）：对位进行取反操作。这通常用于创建掩码或执行某种形式的位反转。

public class TestBinary {
    public static void main(String[] args) {
        int a = 7;
        int b = 10;
        //打印二进制
        //0111 1111 1111 1111 1111 1111 1111 1111  值为2的31次方-1 2147483647
        //printBinary(Integer.MAX_VALUE);


        //负数的二进制转十进制,低31位取反,加1,结果为负数的值
        //1000 0000 0000 0000 0000 0000 0000 0000
        //取反 1111 1111 1111 1111 1111 1111 1111 1111
        //加1  1 1000 0000 0000 0000 0000 0000 0000 0000  值为2的31次方  -2147483648
        //printBinary(Integer.MIN_VALUE);

        //左移,右边用0填充
        //printBinary(a << 1);

        //左移1位,表示一个数*2的1次数,乘以2
        //左移2位,表示一个数*2的2次数,乘以4
        //左移3位,表示一个数*2的3次方,乘以8
        //左移n位,表示一个数*2的n次方
        //getTen(getBinary(a << 4));



        //右移位,左边用符号位填充,处理正数,左边用0填充,处理负数时左边用1填充
        //printBinary(a >> 1);

        //右移1位,表示一个数/2的1次方,除以2
        //右移2位,表示一个数/2的2次方,除以4
        //右移3位,表示一个数/2的3次方,除以8
        //右移n位,表示一个数/2的n次方,除以8
        //getTen(getBinary(a >> 2));


        //右移, 左边用0填充
        //printBinary(a >>> 1);

        //printBinary(a);
        //printBinary(~a);


        printBinary(a);
        printBinary(b);
        //只要有1个为1,结果为1
        printBinary(a | b);
        System.out.println("===============");
        printBinary(a);
        printBinary(b);
        //只有两个都为1,结果位1; 只要有1个为0,结果为0
        printBinary(a & b);
        System.out.println("===============");
        printBinary(a);
        printBinary(b);
        //两个相同时为0,两个值不相同时为1
        printBinary(a ^ b);

    }

    public static void printBinary(int num) {
        StringBuilder s = new StringBuilder();
        for (int i = 31; i >= 0; i--) {
            s.append((num & (1 << i)) == 0 ? "0" : "1");
        }
        for (int i = 0; i < s.length(); i++) {
            System.out.print(s.charAt(i));

            if ((i + 1) % 4 == 0 && i != s.length() - 1) {
                System.out.print(" ");
            }
        }
        System.out.println();
    }

    public static String getBinary(int num) {
        StringBuilder s = new StringBuilder();
        for (int i = 31; i >= 0; i--) {
            s.append((num & (1 << i)) == 0 ? "0" : "1");
        }
        return s.toString();
    }

    public static void getTen(String binaryString){
        int intValueAlternative = 0;
        for (int i = 0; i < binaryString.length(); i++) {
            intValueAlternative = (intValueAlternative << 1) + (binaryString.charAt(i) - '0');
        }
        System.out.println(intValueAlternative);
    }
}

public class TestBinary {

    public static void main(String[] args) {

        /**
         * & 操作的作用, 将1左移后与原数与操作,查看值
         */
        //与操作都为1时为1,判断某个下标的值是否为1
        getTen("00000000000000000000000000000110");
        //获取第3位的值是否为1
        printBinary(4 & (1 << 2));


        /**
         * | 操作的作用, 意昂1左移后与袁术或操作,设置值
         */
        //或操作只要有1个位1,结果为1,用于给某个下标设置值
        getTen("00000000000000000000000000000001");
        //给第2位设置值
        printBinary(1 | (1 << 1));
        //给第3位设置值
        printBinary(1 | (1 << 2));
        //给第4位设置值
        printBinary(1 | (1 << 3));


        /**
         * 异或作用, 任何数自己异或自己结果为0,一个数与0异或,结果都为自己
         * a ^ b ^ b 实际是撤销了b的值
         * 如果你用一个数 a 与另一个数 b 进行异或运算得到结果 c
         * 那么你可以用 c 与 b 再次进行异或运算来恢复原始的 a ==>  a = a ^ b ^ b
         *==================================
         * 切换某1位, 与1进行异或操作,原来为1结果为0,原来为0,结果为1
         *
         */
        //1 1 = 0 ; 1 0 = 1;  0 0 = 1  和自己一样的变为0 ,和自己不一样的变为1
        //一个数自己异或自己结果为0
        //相同为0,不同为1
        //自己为0,另一个自己也为0,结果为0
        //自己为1,另一个自己也为1,结果为0
        //printBinary(a ^ a);

        //相同为0,不同为1
        //一个数异或0,结果都是自己
        //自己为0,另一个是0,结果为0
        //自己为1,另一个是0,结果为1
        //所以1个数异或0,结果都是自己
        //printBinary(a ^ 0);


        System.out.println("============");
        int a = 5;
        int b = 3;
        printBinary(a);
        printBinary(b);

        System.out.println("-----------");
        //此时，a 的值变为了 a 和 b 的异或结果。
        a = a ^ b;
        printBinary(a);
        printBinary(b);
        System.out.println("-----------");

        //由于 a 现在包含 a 和 b 的异或结果
        //再次与 b 进行异或操作将恢复 a 的原始值
        //因为任何数与它自己的异或都是0，然后异或 b 就得到了 a 的原始值
        //但 b 现在变成了 a 和 b 原来的异或结果，也就是原来 a 的值。
        b = a ^ b;
        printBinary(a);
        printBinary(b);
        System.out.println("-----------");
        //现在 a 包含的是 b 的原始值（因为 b 已经被更新为 a 的原始值）
        //再次与 b 进行异或操作，a 就得到了 b 的原始值，而 b 保持为 a 的原始值。
        a = a ^ b;
        // 任何数自己异或自己为0
        // 任何数与0异或都是自己
        // a = a ^ b ^ (a ^b ^ b)  ==> a = b
        //a ^ b ^ b 实际是撤销了b的值
        printBinary(a);
        printBinary(b);

        //如果你用一个数 a 与另一个数 b 进行异或运算得到结果 c
        //那么你可以用 c 与 b 再次进行异或运算来恢复原始的 a ==>  a = a ^ b ^ b
        //这是因为在二进制中，一个数与它自己异或的结果是0，而任何数与0异或都会保持原数不变。

    }

    public static void printBinary(int num) {
        StringBuilder s = new StringBuilder();
        for (int i = 31; i >= 0; i--) {
            s.append((num & (1 << i)) == 0 ? "0" : "1");
        }
        for (int i = 0; i < s.length(); i++) {
            System.out.print(s.charAt(i));

            if ((i + 1) % 4 == 0 && i != s.length() - 1) {
                System.out.print(" ");
            }
        }
        System.out.println();
    }

    public static String getBinary(int num) {
        StringBuilder s = new StringBuilder();
        for (int i = 31; i >= 0; i--) {
            s.append((num & (1 << i)) == 0 ? "0" : "1");
        }
        return s.toString();
    }

    public static void getTen(String binaryString) {
        int intValueAlternative = 0;
        for (int i = 0; i < binaryString.length(); i++) {
            intValueAlternative = (intValueAlternative << 1) + (binaryString.charAt(i) - '0');
        }
        System.out.println(intValueAlternative);
    }
}

public class TestBinary {

    public static void main(String[] args) {

        /**
         * ~ 作用,获取到一个全为1的二进制
         * 用这个值进行左移或者右移操作,将那些位置(左移或者右移)的值为0
         * 和另一数进行与操作,会将另一个数那些位置的值变为0,屏蔽掉那些那些位置的值
         * 不会改变其他位置的值
         */
        printBinary(~0);

        getTen("0001100001100000000000011011110");
        //利用0取反,获取到全为1的二进制
        //将二进制数右8位,使低位都为0
        printBinary(~0 << 8);
        //将一个数与上边的数取与运算,会将低8位的数屏蔽掉
        printBinary(204472542 & (~0 << 8));

    }

    public static void printBinary(int num) {
        StringBuilder s = new StringBuilder();
        for (int i = 31; i >= 0; i--) {
            s.append((num & (1 << i)) == 0 ? "0" : "1");
        }
        for (int i = 0; i < s.length(); i++) {
            System.out.print(s.charAt(i));

            if ((i + 1) % 4 == 0 && i != s.length() - 1) {
                System.out.print(" ");
            }
        }
        System.out.println();
    }

    public static String getBinary(int num) {
        StringBuilder s = new StringBuilder();
        for (int i = 31; i >= 0; i--) {
            s.append((num & (1 << i)) == 0 ? "0" : "1");
        }
        return s.toString();
    }

    public static void getTen(String binaryString) {
        int intValueAlternative = 0;
        for (int i = 0; i < binaryString.length(); i++) {
            intValueAlternative = (intValueAlternative << 1) + (binaryString.charAt(i) - '0');
        }
        System.out.println(intValueAlternative);
    }
}

public class TestBinary {

    public static void main(String[] args) {


        getTen("0001100001100000000000011011110");
        /**
         * 获取低16位的值,将高16位的值屏蔽掉
         */
        //将高16位变为0
        printBinary(~0 >>> 16 );
        //屏蔽高16位的值,获取到低16位的值
        printBinary(204472542 & (~0 >>> 16));

        //直接利用一个高16位的数位0,低16位全为1的数进行与操作
        printBinary(204472542 & 0xFFFF);


        /**
         * 获取高16位的值,将低16位的值屏蔽掉
         */
        // 将低16位变为0
        printBinary(~0 << 16 );
        //屏蔽低16位的值,获取到了高16位的值
        printBinary(204472542 & (~0 << 16));

        //直接将低16位的值右移排除掉
        printBinary(204472542 >>>16);
        
    }

    public static void printBinary(int num) {
        StringBuilder s = new StringBuilder();
        for (int i = 31; i >= 0; i--) {
            s.append((num & (1 << i)) == 0 ? "0" : "1");
        }
        for (int i = 0; i < s.length(); i++) {
            System.out.print(s.charAt(i));

            if ((i + 1) % 4 == 0 && i != s.length() - 1) {
                System.out.print(" ");
            }
        }
        System.out.println();
    }

    public static String getBinary(int num) {
        StringBuilder s = new StringBuilder();
        for (int i = 31; i >= 0; i--) {
            s.append((num & (1 << i)) == 0 ? "0" : "1");
        }
        return s.toString();
    }

    public static void getTen(String binaryString) {
        int intValueAlternative = 0;
        for (int i = 0; i < binaryString.length(); i++) {
            intValueAlternative = (intValueAlternative << 1) + (binaryString.charAt(i) - '0');
        }
        System.out.println(intValueAlternative);
    }
}