补码、原码、反码-移位操作 编解码

     数据在计算机中都是按照字节存储的，1个字节等于8位（1Byte=8bit），而计算机只能识别0和1这两个数，所以根据排列，1个字节能代表256种不同的信息，即28（0和1两种可能，8位排列）。

       整数（4Byte）分为：有符号和无符号整数。在计算机存储中最高位代表符号位，如果最高位是0表示是负数，最高位是1表示是正数。负整数在计算机中是以补码形式储存的，补码是怎么样表示的呢，这里还要引入另一个概念——反码，所谓反码就是把负数的原码（负数的原码和和它的绝对值所对应的原码相同，简单的说就是绝对值相同的数原码相同）各个位按位取反，是1就换成0，是0就换成1，如-1的原码是00000001，和1的原码相同，那么-1的反码就是11111110，而补码就是在反码的基础上加1，即-1的补码是11111110+1=11111111，因此我们可以算出-1在计算机中是按11111111储存的。总结一下，计算机储存有符号的整数时，是用该整数的补码进行储存的，0的原码、补码都是0，正数的原码、补码可以特殊理解为相同，负数的补码是它的反码加1。

        Java数值计算Java中的移位，如果是short，char，byte的话，都会转换成int的形式再进行移位的。

试看：1.） byte a = 27;// 转换成int为 00000000000000000000000000011011
                   byte b = -1;转换成int为 11111111111111111111111111111111
int g = a >> 1;

// 有符号右移1位，左侧缺的位以符号位补齐，正数就是0， "00000000000000000000000000001101" = 13int f = b>> 1;

// 有符号右移1位，左侧缺的位以符号位补齐，负数就是1，“11111111111111111111111111111111”=   -1
故此时打印出来，g=13，gf=-1。
g = a >>> 1;

// 无符号右移1位，左侧缺的位以0补齐，"00000000000000000000000000001101" = 13f = b>>> 1;

// 无符号右移1位，左侧缺的位以0补齐，“01111111111111111111111111111111”=   2147483647
故此时打印出来，g=13，gf=2147483647。
f = b<< 1;

// 无符号左移1位，右侧缺的位以0补齐，“10000000000000000000000000000010“=   -2故此时打印出来，f= -2
在Thinking   in   Java第三章中的一段话:移位运算符面向的运算对象也是二进制的“位”。可单独用它们处理整数类型（主类型的一种）。

左移位运算符（<<）能将运算符左边的运算对象向左移动运算符右侧指定的位数（在低位补0）。

“有符号”右移位运算符（>>）则将运算符左边的运算对象向右移动运算符右侧指定的位数。

“有符号”右移位运算符使用了“符号扩展”：若值为正，则在高位插入0；若值为负，则在高位插入1。Java也添加了一种“无符号”右移位运算符（>>>），它使用了“零扩展”：无论正负，都在高位插入0。这一运算符是C或C++没有的。     

若对char，byte或者short进行移位处理，那么在移位进行之前，它们会自动转换成一个int。只有右侧的5个低位才会用到。这样可防止我们在一个int数里移动不切实际的位数。若对一个long值进行处理，最后得到的结果也是long。此时只会用到右侧的6个低位，防止移动超过long值里现成的位数。但在进行“无符号”右移位时，也可能遇到一个问题。若对byte或short值进行右移位运算，得到的可能不是正确的结果（Java1.0和Java1.1特别突出）。它们会自动转换成int类型，并进行右移位。但“零扩展”不会发生，所以在那些情况下会得到-1的结果。

    //整型4字节32位
 public byte[] int2byte(int a)
 {
  byte[] bt = new byte[4];
  bt[0] = (byte) ((a & 0xff000000) >> 24);
  bt[1] = (byte) ((a & 0x00ff0000) >> 16);
  bt[2] = (byte) ((a & 0x0000ff00) >> 8);
  bt[3] = (byte) (a & 0x000000ff);
  return bt;
 }

 

  // 整数到字节数组转换

 public static byte[] int2bytes(int n) {

 byte[] ab = new byte[4];

 ab[0] = (byte) (0xff & n);

 ab[1] = (byte) ((0xff00 & n) >> 8);

 ab[2] = (byte) ((0xff0000 & n) >> 16);

 ab[3] = (byte) ((0xff000000 & n) >> 24);

 return ab;

 }

 

 // 字节数组到整数的转换

 public static int bytes2int(byte b[]) {

 int s = 0;

 s = ((((b[0] & 0xff) << 8 | (b[1] & 0xff)) << 8) | (b[2] & 0xff)) << 8

 | (b[3] & 0xff);

 return s;

 }

 private final static byte[] hex = "0123456789ABCDEF".getBytes();

 

 private static int parse(char c) {

 if (c >= 'a')

 return (c - 'a' + 10) & 0x0f;

 if (c >= 'A')

 return (c - 'A' + 10) & 0x0f;

 return (c - '0') & 0x0f;

 }

 

 // 从字节数组到十六进制字符串转换

 public static String Bytes2HexString(byte[] b) {

 byte[] buff = new byte[2 * b.length];

 for (int i = 0; i < b.length; i++) {

 buff[2 * i] = hex[(b[i] >> 4) & 0x0f];

 buff[2 * i + 1] = hex[b[i] & 0x0f];

 }

 return new String(buff);

 }

 

 // 从十六进制字符串到字节数组转换

 public static byte[] HexString2Bytes(String hexstr) {

 byte[] b = new byte[hexstr.length() / 2];

 int j = 0;

 for (int i = 0; i < b.length; i++) {

 char c0 = hexstr.charAt(j++);

 char c1 = hexstr.charAt(j++);

 b[i] = (byte) ((parse(c0) << 4) | parse(c1));

 }

 return b;

 }