byte & 0xff char 转换

https://blog.csdn.net/lixingtao0520/article/details/75450883

版权声明：本文为博主原创文章，转载请注明作者与出处，http://blog.csdn.net/lixingtao0520 https://blog.csdn.net/lixingtao0520/article/details/75450883
     在Java中 byte型数据在内存中占8位，int型数据在内存中占32位。0xff默认为int型，是十六进制，十进制中表示为255，二进制为32位，后八位为'1111 1111'，其他24位均为0；在&运算时，2个bit均为1，则得1，否则得0。

     先看以下程序

byte a = -17;
System.out.println(a);
System.out.println((int) a);
System.out.println(a & 0xff);
System.out.println(Integer.toBinaryString((int) a));
System.out.println(Integer.toBinaryString(a & 0xff));
运行程序输出以下结果:

说明:

1、a是byte型时，二进制表示为11101111；即-17(byte型)；
2、a在强制转化为int型时，值仍为-17，转换规则：如果是负数，则高位补1，如果是正数，则高位补0。所以，a的值仍为-17(int型)，二进制表示形式为'11111111111111111111111111101111'。
3、a & 0xff 操作时，因为a为byte型，所以会将a自动转化为int型(高位补1)，再与0xff进行&操作，返回的数值二进制表示为'00000000000000000000000011101111'（toBinaryString方法省略了左边的0），此数值为239(int型)。
4、byte & 0xff操作一般将byte数据转换成int型，最终的数据只有低8位有数据，其他位为0。
5、Java中byte型转换为int型有两种：一种是保持数值不变，例如进行数值计算时，此时可采用强制类型转换，int b = (int) a ；另外一种是最低字节中各个位不变，高位用0填充，此时需要采用位操作 int b = a & 0xff，例如在编解码时，以及BufferedInputStream中的read方法。
public synchronized int read() throws IOException {
if (pos >= count) {
fill();
if (pos >= count)
return -1;
}
return getBufIfOpen()[pos++] & 0xff;
}

---------------------
作者：BiggerLee
来源：CSDN
原文：https://blog.csdn.net/lixingtao0520/article/details/75450883
版权声明：本文为博主原创文章，转载请附上博文链接！

https://blog.csdn.net/iblade/article/details/73289831

在MD5运算中 通常会把MD5（十六进制的byte[]）转成HexString, 
会用到一个方法

 private static String bytesToHex1(byte[] md5Array) {
        StringBuilder strBuilder = new StringBuilder();
        for (int i = 0; i < md5Array.length; i++) {
            int temp = 0xff & md5Array[i];//TODO:此处为什么添加 0xff & ？
            String hexString = Integer.toHexString(temp);
            if (hexString.length() == 1) {//如果是十六进制的0f，默认只显示f，此时要补上0
                strBuilder.append("0").append(hexString);
            } else {
                strBuilder.append(hexString);
            }
        }
        return strBuilder.toString();
    }

又如此段代码：

 byte[] bs = digest.digest(origin.getBytes(Charset.forName(charsetName))) ;  

        for (int i = 0; i < bs.length; i++) {  
            int c = bs[i] & 0xFF ;
            if(c < 16){ 
                sb.append("0");  
            }  
            sb.append(Integer.toHexString(c)) ;  
        }  
        return sb.toString() ; 

反复出现byte & 0xff 到底在做什么？

举个简单的例子:

byte[] b = new byte[5];

b[0] = -12;

byte 8位二进制 = 1个字节 char 2个字节 short (2个字节) int（4个字节） long（8个字节） float （4个字节） double（8个字节）

计算机存储数据机制：正数存储的二进制原码,负数存储的是二进制的补码。 补码是负数的绝对值反码加1。

比如-12，-12 的绝对值原码是：0000 1100 取反： 1111 0011 加1： 1111 0100

byte –> int 就是由8位变 32 位 高24位全部补1： 1111 1111 1111 1111 1111 1111 1111 0100 ;

0xFF 是计算机十六进制的表示： 0x就是代表十六进制，A B C D E F 分别代表10 11 12 13 14 15 F就是15 一个F 代表4位二进制：可以看做 是 8 4 2 1。

0xFF的二进制表示就是：1111 1111。 高24位补0：0000 0000 0000 0000 0000 0000 1111 1111;

-12的补码与0xFF 进行与（&）操作 最后就是0000 0000 0000 0000 0000 0000 1111 0100

转换为十进制就是 244。

byte类型的数字要&0xff再赋值给int类型，其本质原因就是想保持二进制补码的一致性。

当byte要转化为int的时候，高的24位必然会补1，这样，其二进制补码其实已经不一致了，&0xff可以将高的24位置为0，低8位保持原样。这样做的目的就是为了保证二进制数据的一致性。

有人问为什么上面的式子中b[0]不是8位而是32位，因为当系统检测到byte可能会转化成int或者说byte与int类型进行运算的时候，就会将byte的内存空间高位补1（也就是按符号位补位）扩充到32位，再参与运算。
--------------------- 
作者：iblade 
来源：CSDN 
原文：https://blog.csdn.net/iblade/article/details/73289831 
版权声明：本文为博主原创文章，转载请附上博文链接！

 https://blog.csdn.net/u011080472/article/details/51280919

https://blog.csdn.net/zhaominpro/article/details/79602381

https://blog.csdn.net/xiaozhouchou/article/details/79086604

    public static void main(String[] args) {
         int i = 1;
         int k = 0;
         for(int j = 0;j<33;j++){
              i = i << 1;
             System.out.println(Integer.toBinaryString( i));
             System.out.println(i);
         }
         System.out.println(i);
    }




2
100
4
1000
8
10000
16
100000
32
1000000
64
10000000
128
100000000
256
1000000000
512
10000000000
1024
100000000000
2048
1000000000000
4096
10000000000000
8192
100000000000000
16384
1000000000000000
32768
10000000000000000
65536
100000000000000000
131072
1000000000000000000
262144
10000000000000000000
524288
100000000000000000000
1048576
1000000000000000000000
2097152
10000000000000000000000
4194304
100000000000000000000000
8388608
1000000000000000000000000
16777216
10000000000000000000000000
33554432
100000000000000000000000000
67108864
1000000000000000000000000000
134217728
10000000000000000000000000000
268435456
100000000000000000000000000000
536870912
1000000000000000000000000000000
1073741824
10000000000000000000000000000000
-2147483648
0
0
0
0