二进制知识
其原因在于:
1.byte的大小为8bits而int的大小为32bits
2.java的二进制采用的是补码形式
在这里先温习下计算机基础理论
byte是一个字节保存的，有8个位，即8个0、1。
8位的第一个位是符号位，
也就是说0000 0001代表的是数字1
1000 0000代表的就是-1
所以正数最大位0111 1111，也就是数字127
负数最大为1111 1111，也就是数字-128
上面说的是二进制原码，但是在java中采用的是补码的形式，下面介绍下什么是补码
1、反码：
一个数如果是正，则它的反码与原码相同；
一个数如果是负，则符号位为1，其余各位是对原码取反；
2、补码：利用溢出，我们可以将减法变成加法
对于十进制数，从9得到5可用减法：
9－4＝5 因为4+6＝10，我们可以将6作为4的补数
改写为加法：
9+6＝15（去掉高位1，也就是减10）得到5.
对于十六进制数，从c到5可用减法：
c－7＝5 因为7+9＝16 将9作为7的补数
改写为加法：
c+9＝15（去掉高位1，也就是减16）得到5.
在计算机中，如果我们用1个字节表示一个数，一个字节有8位，超过8位就进1，在内存中情况为（100000000），进位1被丢弃。
⑴一个数为正，则它的原码、反码、补码相同
⑵一个数为负，刚符号位为1，其余各位是对原码取反，然后整个数加1
例如:
- 1的原码为 10000001
- 1的反码为 11111110
+ 1
- 1的补码为 11111111
0的原码为 00000000
0的反码为 11111111（正零和负零的反码相同）
+1
0的补码为 100000000（舍掉打头的1，正零和负零的补码相同）
Java 中的一个byte，其范围是-128~127的，如果不进行&0xff，那么当一个byte会转换成int时，对于负数，会做位扩展，举例来说，一个byte的-1（即0xff），会被转换成int的-1（即0xffffffff ）， 那么转化出的结果就不是我们想要的了。
而0xff默认是整形，所以，一个byte跟0xff相与会先将那个byte转化成整形运算，结果的高24位就会被清0，这是我们想要的结果。
/* * Created on 2004-11-5 * * TODO To change the template for this generated file go to * Window - Preferences - Java - Code Style - Code Templates */package converter;/** * @author NetSniffer * * TODO To change the template for this generated type comment go to * Window - Preferences - Java - Code Style - Code Templates */public class IntByteConvertor { public static byte[] int2Byte(int intValue){ byte[] b=new byte[4]; for(int i=0;i<4;i++){ b[i]=(byte)(intValue>>8*(3-i) & 0xFF); //System.out.print(Integer.toBinaryString(b[i])+" "); System.out.print((b[i]& 0xFF)+" "); } return b; } public static int byte2Int(byte[] b){ int intValue=0,tempValue=0xFF; for(int i=0;i<b.length;i++){ intValue +=(b[i] & 0xFF)<<(8*(3-i)); //System.out.print(Integer.toBinaryString(intValue)+" "); } return intValue; } public static void main(String[] args) { System.out.println(byte2Int(int2Byte(1000))); }}/** * 将指定byte数组以16进制的形式打印到控制台 * @param hint String * @param b byte[] * @return void */ public static void printHexString(String hint, byte[] b) { System.out.print(hint); for (int i = 0; i < b.length; i++) { String hex = Integer.toHexString(b[i] & 0xFF); if (hex.length() == 1) { hex = '0' + hex; } System.out.print(hex.toUpperCase() + " "); } System.out.println(""); } /** * * @param b byte[] * @return String */ public static String Bytes2HexString(byte[] b) { String ret = ""; for (int i = 0; i < b.length; i++) { String hex = Integer.toHexString(b[i] & 0xFF); if (hex.length() == 1) { hex = '0' + hex; } ret += hex.toUpperCase(); } return ret; } /** * 将两个ASCII字符合成一个字节； * 如："EF"--> 0xEF * @param src0 byte * @param src1 byte * @return byte */ public static byte uniteBytes(byte src0, byte src1) { byte _b0 = Byte.decode("0x" + new String(new byte[]{src0})).byteValue(); _b0 = (byte)(_b0 << 4); byte _b1 = Byte.decode("0x" + new String(new byte[]{src1})).byteValue(); byte ret = (byte)(_b0 ^ _b1); return ret; } /** * 将指定字符串src，以每两个字符分割转换为16进制形式 * 如："2B44EFD9" --> byte[]{0x2B, 0x44, 0xEF, 0xD9} * @param src String * @return byte[] */ public static byte[] HexString2Bytes(String src){ byte[] ret = new byte[src.length/2]; byte[] tmp = src.getBytes(); for(int i=0; i<src.length/2; i++){ ret[i] = uniteBytes(tmp[i*2], tmp[i*2+1]); } return ret; }/** * 将一个长度为4的String前2位和后2位互换,再将字符转成十进制数 用来进行高低字节转换 * @param String * @return int * */ public static int HexStringToInt(String src){ String s1=src.substring(0,2); String s2=src.substring(2,4); int i=Integer.parseInt(s2+s1,16); return i; }为何与0xff进行与运算在剖析该问题前请看如下代码public static String bytes2HexString(byte[] b) { String ret = ""; for (int i = 0; i < b.length; i++) { String hex = Integer.toHexString(b[ i ] & 0xFF); if (hex.length() == 1) { hex = '0' + hex; } ret += hex.toUpperCase(); } 使用以下的语句，就可以区分使用&0xff和不使用的区别了 System.out.println(Integer.toBinaryString(b & 0xff)); 输出结果：000000000000000000000000 11010110 System.out.println(Integer.toBinaryString(b)); 输出结果： 111111111111111111111111 11010110 return ret;}代码解析：注意这里b[ i ] & 0xFF将一个byte和 0xFF进行了与运算。b[ i ] & 0xFF运算后得出的仍然是个int,那么为何要和 0xFF进行与运算呢?直接 Integer.toHexString(b[ i ]);将byte强转为int不行吗?答案是不行的.其原因在于:1.byte的大小为8bits而int的大小为32bits2.java的二进制采用的是补码形式 byte是一个字节保存的，有8个位，即8个0、1。8位的第一个位是符号位，也就是说0000 0001代表的是数字11000 0000代表的就是-1所以正数最大位0111 1111，也就是数字127负数最大为1111 1111，也就是数字-128 上面说的是二进制原码，但是在java中采用的是补码的形式，下面介绍下什么是补码1、反码：一个数如果是正，则它的反码与原码相同； 一个数如果是负，则符号位为1，其余各位是对原码取反；举个例子：2 二进制吗为 00000010，因为是正数，所以其反码也是 00000010如果是-2那么，就要把最高位变为1，其他7位按照其正数的位置取反。2、补码：利用溢出，我们可以将减法变成加法：对于十进制数，从9得到5可用减法： 9－4＝5 因为4+6＝10，我们可以将6作为4的补数 改写为加法： +6＝15（去掉高位1，也就是减10）得到5. 对于十六进制数，从c到5可用减法： c－7＝5 因为7+9＝16 将9作为7的补数 改写为加法： c+9＝15（去掉高位1，也就是减16）得到5.在计算机中，如果我们用1个字节表示一个数，一个字节有8位，超过8位就进1，在内存中情况为（100000000），进位1被丢弃。⑴一个数为正，则它的原码、反码、补码相同⑵一个数为负，刚符号位为1，其余各位是对原码取反，然后整个数加1- 1的原码为 10000001- 1的反码为 11111110 + 1- 1的补码为 11111111 0的原码为 000000000的反码为 11111111（正零和负零的反码相同） +10的补码为 100000000（舍掉打头的1，正零和负零的补码相同）Integer.toHexString的参数是int，如果不进行&0xff，那么当一个byte会转换成int时，由于int是32位，而byte只有8位这时会进行补位，例如补码11111111的十进制数为-1转换为int时变为11111111 11111111 11111111 11111111好多1啊，呵呵！即0xffffffff但是这个数是不对的，这种补位就会造成误差。和0xff相与后，高24比特就会被清0了，结果就对了。Java中的一个byte，其范围是-128~127的，而Integer.toHexString的参数本来是int，如果不进行&0xff，那么当一个byte会转换成int时，对于负数，会做位扩展，举例来说，一个byte的-1（即0xff），会被转换成int的-1（即0xffffffff），那么转化出的结果就不是我们想要的了。而0xff默认是整形，所以，一个byte跟0xff相与会先将那个byte转化成整形运算，这样，结果中的高的24个比特就总会被清0，于是结果总是我们想要的。 0xFF （十进制1）二进制码：00000000 00000000 00000000 11111111与 0xff 做 & 运算会将 byte 值变成 int 类型的值，也将 -128～0 间的负值都转成正值了。char c = (char)-1 & 0xFF;char d = (char)-1;System.out.println((int)c); 255System.out.println((int)d); 65535 java中的數值是int,所以0xFF是int,而byte是有符號數,int亦然,直接由byte升為int,符號自動擴展,而進行了& 0xFF後,就把符號問題忽略掉了,將byte以純0/1地引用其內容,所以要0xFF,不是多餘的,你用一些Stream讀取文件的byte就知道了,我昨天搞了一天,就不明白為什麼讀出來的數某些byte會在移位後錯誤的,就是因為這個原因. 把number转换为二进制，只取最低的8位（bit）。因为0xff二进制就是1111 1111& 运算是，如果对应的两个bit都是1，则那个bit结果为1，否则为0.比如 1010 & 1101 = 1000 （二进制）由于0xff最低的8位是1，因此number中低8位中的&之后，如果原来是1，结果还是1，原来是0，结果位还是0.高于8位的，0xff都是0，所以无论是0还是1，结果都是0.