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);
}