java中int强转为byte问题思考

1. int强转为byte

System.out.println((byte)2003); // -45

2. 十进制数和二进制数互转

十进制数转为二进制数
1.Interger.toString()方法
	Integer.toString(5,2) // 101
2.BigInteger.toString()
  BigInteger bigInteger = new BigInteger("15");
  String string = bigInteger.toString(2);	// 1111

二进制转为10进制数
Integer.valueOf("1111", 2) // 15
Integer.toHexString(num)
Integer.toOctalString(num)
Integer.toBinaryString(num)

3. 数据类型字节长度

byte：1字节、8位比特
short：2字节、16位比特
int：4字节、32位比特
long：8字节、64位比特

4. 二进制相关运算

原码、反码与补码的关系
正数： 原码 = 反码 = 补码
负数： 原码取反 = 反码（符号位不变）； 反码 + 1 = 补码（符号位上的进位舍弃） 计算时先去除符号位
注意： 补码 10000000 是一个特殊的补码，对应10进制数位-128，即不存在 -0

^ 异或运算符	对应数值的二进制由高至低，相同的为 0 ，不同为1
		int a = 0b0101;
        int b = 0b1010;
		// a b 的异或运算结果 应为 1111
        System.out.println(Integer.toBinaryString(a ^ b));

& 与运算符		对应数值的二进制由高至低，同时为1 ，则为1 ，否则为 0
		int a = 0b10101;
        int b = 0b11010;
		// a b 与 计算结果应为 10000
        System.out.println(Integer.toBinaryString(a & b));

| 或运算符		对应数值的二进制由高至低，有一个为1 ，则为1 ，否则为 0
		int a = 0b101010;
        int b = 0b110100;
		// a b 或 计算结果应为 111110
        System.out.println(Integer.toBinaryString(a | b));

按位取反 ~		
	~1=0,~0=1
    ~14=-15

>> 右移动运算符  无符号的右移位 >>>    a >> n 即a对应的二进制数字 向右移动 n位 ， 左边补 0
	int a = 0b101010;
	// a >> 2 即为 0b1010
	System.out.println(Integer.toBinaryString(a >> 2));


<< 左移运算符  a << n 即a对应的二进制数字 向左移动 n位，右边补n个 0 
	int a = 0b101010;
	// a << 2 即为 0b10101000
	System.out.println(Integer.toBinaryString(a << 2)); // 10101000

也可以两个int数进行二进制运算	
	1&1=1、1&0=0、0&1=0、0&0=0	14&3=2 	
	1|1=1, 1|0=1, 0|1=1, 0|0=0	14|3=15
	1^1=0, 1^0=1,0^1=1,0^0=0 14^3=13
	~1=0,	~0=1	~14=-15

5. int 强转byte分析

当int类型强转为byte类型时，计算机会截取最后的八位（1个字节；
由于计算机存储数据时，都是以补码的形式进行存储。
我们通常看到的数却是计算机存储的补码先转换成反码，后转换成原码，再转换成十进制呈现的

如 (byte)233 // -23 计算过程
第一步：int类型占32位，将233先转化为二进制00000000 00000000 00000000 11101001，
第二步：截取最后的八位，byte类型占8位所以得到11101001，第一位是1，说明是负数；
第三步：取反码得到10010110（第一位不参与计算），给反码加1（第一位不参与计算）得到10010111–> -23（即0010111是23，符号位1，所以是-23）
注意： 补码 10000000 是一个特殊的补码，对应10进制数位-128，即不存在 -0

6. 封装工具类

/**
 * 二进制数工具类
 *
 * @author liuxb
 * @date 2022/5/8 10:52
 **/
public class BinaryUtil {
    /**
     * 十六进字符串制转二进制字符串
     *
     * @param number 16进制数字符串
     * @return
     */
    public static String hexToBin(String number) {
        Integer hex = Integer.valueOf(number, 16);
        return Integer.toBinaryString(hex);
    }

    /**
     * 二进制数原码转反码
     *
     * @param number 二进制数字符串
     * @return
     */
    public static String binOriginalToBack(String number) {
        if (number.startsWith("0")) {
            return number;
        } else {
            StringBuffer sb = new StringBuffer();
            sb.append("1");
            String sub = number.substring(1);
            for (int i = 0; i < sub.length(); i++) {
                if (sub.charAt(i) == '0') {
                    sb.append("1");
                } else if (sub.charAt(i) == '1') {
                    sb.append("0");
                }
            }
            return sb.toString();
        }
    }

    /**
     * 二进制数反码转补码
     *
     * @param number 8位二进制数反码字符串
     * @return
     */
    public static String binBackToRepair(String number) {
        if (number.startsWith("0")) {
            return number;
        }
        StringBuilder sb = new StringBuilder();
        int x = 0;
        int y = 0;
        int pre = 0;//进位
        int sum = 0;//存储进位和另两个位的和

        // 负数，先去除符号位，反码转补码加1
        String a = number.substring(1);
        String b = "1";
        while (a.length() != b.length()) {//将两个二进制的数位数补齐,在短的前面添0
            if (a.length() > b.length()) {
                b = "0" + b;
            } else {
                a = "0" + a;
            }
        }
        for (int i = a.length() - 1; i >= 0; i--) {
            x = a.charAt(i) - '0';
            y = b.charAt(i) - '0';
            sum = x + y + pre;//从低位做加法
            if (sum >= 2) {
                pre = 1;//进位
                sb.append(sum - 2); //当前位
            } else {
                pre = 0;
                sb.append(sum); //当前位
            }
        }
        //7位数计算完，pre = 1，不能再进位，符号位上的进位舍弃
        sb.append("1"); //补上符号位
        return sb.reverse().toString();//翻转返回
    }

    /**
     * 二进制数补码转十进制数(实际值)
     *
     * @param number 二进制数字符串
     * @return
     */
    public static int binRepairToDec(String number) {
        String sub = number.substring(1);
        if (number.startsWith("0")) {
            return Integer.valueOf(sub, 2);
        } else if (number.equals("10000000")) {
            return -128;
        } else {
            return -(Integer.valueOf(sub, 2));
        }
    }

    /**
     * 二进制数原码转为十进制数(实际值)
     * @param number 二进制数原码
     * @return
     */
    public static int binOriginalToDec(String number) {
        return binRepairToDec(binOriginalToRepair(number));
    }

    /**
     * 二进制数原码转为补码
     *
     * @param number 二进制数原码
     * @return
     */
    public static String binOriginalToRepair(String number) {
        return binBackToRepair(binOriginalToBack(number));
    }

    public static void main(String[] args) {
        System.out.println(binOriginalToBack("11010011"));
        System.out.println(binBackToRepair("11111111"));
        System.out.println(binBackToRepair("11111110"));
        System.out.println(binRepairToDec("11010011"));
        System.out.println(binRepairToDec("10000000"));
        System.out.println(binRepairToDec("11111111"));
        System.out.println(binRepairToDec("01111111"));
    }
}

7.不强转的 intToByte方法

public static int intToByte(int a){
        //第一步：int类型占32位，将2003先转化为二进制 11111010011
        String b = Integer.toBinaryString(a);
        while(b.length() < 32){
            b = '0' + b;
        }
     //第二步：byte类型占8位所以得到11010011，第一位是1，说明是负数
        String last8 = b.substring(24);
        //第三步：取反码得到10101100（第一位不参与计算），给反码加1得到10101101–> -45
        return BinaryUtil.binOriginalToDec(last8);
    }