关闭

Java中十六进制转换 Integer.toHexString()

94人阅读 评论(0) 收藏 举报
分类:

载自:http://jiangzhengjun.iteye.com/blog/506041


    博客分类: 
  • Java

为了显示一个byte型的单字节十六进制(两位十六进制表示)的编码,请使用:

Integer.toHexString((byteVar & 0x000000FF) | 0xFFFFFF00).substring(6)

 byteVar & 0x000000FF的作用是,如果byteVar 是负数,则会清除前面24个零,正的byte整型不受影响。(...) | 0xFFFFFF00的作用是,如果byteVar 是正数,则置前24位为一,这样toHexString输出一个小于等于15的byte整型的十六进制时,倒数第二位为零且不会被丢弃,这样可以通过substring方法进行截取最后两位即可。

 

Java代码  收藏代码
  1. import junit.framework.TestCase;  
  2.   
  3. public class Hex extends TestCase {  
  4.   
  5.     public void testPositiveIntToHex() {  
  6.         //如果正数小于15时,只输入一位,而不是按我们想像的两位标准十六进制输出显示的,后面解决这个问题  
  7.         System.out.println(Integer.toHexString(2));//2  
  8.         System.out.println(Integer.toHexString(15));//f  
  9.         System.out.println(Integer.toHexString(16));//10  
  10.         System.out.println(Integer.valueOf("F"16));//16  
  11.     }  
  12.   
  13.     /* 
  14.      * Integer.valueOf()实质上调用的是Integer.parseInt()来完成的,所以 
  15.      * Integer.parseInt()与Integer.valueOf()功能是一样的,只是返回值不 
  16.      * 一样而已 
  17.      */  
  18.     public void testNegativeIntToHex() {  
  19.         //负整数时,前面输入了多余的 FF ,没有去掉前面多余的 FF,按并双字节形式输出  
  20.         System.out.println(Integer.toHexString(-2).toUpperCase());//FFFFFFFE  
  21.   
  22.         //实质上0xFF会像转换成0x000000FF后再进行位运算  
  23.         System.out.println(Integer.toHexString(-2 & 0xFF).toUpperCase());//FE  
  24.         System.out.println(Integer.toHexString(-2 & 0x000000FF).toUpperCase());//FE  
  25.   
  26.         //注,FE输出时不会为-2,因为此时不会把FE看成负数,valueOf会把所有数字串看成正的  
  27.         System.out.println(Integer.valueOf("FE"16));//254  
  28.         //如果要输出-2,只能按以下形式输出  
  29.         System.out.println(Integer.valueOf("-2"16));//-2  
  30.   
  31.         //所以要把 FE 看成负的话,只能在前面加上负号,但是这里输出还不是-2,  
  32.         //而是先计算Integer.valueOf("FE", 16),再在结果前加上负  
  33.         System.out.println(Integer.valueOf("-FE"16));//-254  
  34.   
  35.         /* 所以如果要输入某个负数,我们只能先求出该数的绝对值的原码十六进制,再在前面加上负号, 
  36.          * 例如求表示-128,则先对绝对值128求十六进制 80,再在前面加上负号 -80 
  37.          */  
  38.         System.out.println(Integer.valueOf("-80"16));//-128  
  39.   
  40.         /* 为什么说valueOf把所有数字串看成正的呢?请看下面三行代码,因为最大正数为2147483647, 
  41.          * 如果再  在7fffffff基础上加上一个一,运行肯定会出错误(这与直接输出0x80000000不一样), 
  42.          * 那么就可以证明 
  43.          */  
  44.         System.out.println(Integer.valueOf("7fffffff"16));//2147483647  
  45.         //此句运行时会报错,因为最大正数为7fffffff,但如 -80000000 却又可以运行,因为没超出整数范围  
  46.         //System.out.println(Integer.valueOf("80000000", 16));//不能运行,已注掉  
  47.         System.out.println(Integer.valueOf("-80000000"16));//-2147483648  
  48.   
  49.         /* 注,输出时不是负数,而是正,因为0xFE只有8位,而整数是32位,所以以int形式出现时前 
  50.          * 面会自动补24个零,第一位是零,所以最后是正数 
  51.          */  
  52.         System.out.println(0xFE);//254  
  53.         System.out.println(-0xFE);//-254  
  54.         //但0x80000000已满,无需补,第一位为一,所以最后为负数  
  55.         System.out.println(0x80000000);//-2147483648  
  56.     }  
  57.   
  58.     public void testNegativeIntToBin() {  
  59.         System.out.println(Integer.toBinaryString(-2));//11111111111111111111111111111110  
  60.         //实质上0xFF会像转换成0x000000FF后再进行位运算  
  61.         System.out.println(Integer.toBinaryString(-2 & 0xFF));//11111110  
  62.         System.out.println(Integer.toBinaryString(-2 & 0x000000FF));//11111110  
  63.   
  64.         //与上面十六进制是一样的  
  65.         System.out.println(Integer.valueOf("1111111111111111111111111111111"2));//2147483647  
  66.         //下面语句运行会出错,已注掉  
  67.         //System.out.println(Integer.valueOf("10000000000000000000000000000000", 2));  
  68.         System.out.println(Integer.valueOf("-10000000000000000000000000000000"2));//-2147483648  
  69.         System.out.println(Integer.valueOf("11111110"2));//254  
  70.         System.out.println(Integer.valueOf("-11111110"2));//-254  
  71.   
  72.         /* 注,Java中没有直接使用二进制表示一个数(目前只支持八与十六进制直接表示法),下面其实是一个 
  73.          * 八进制的数与十进制的数 
  74.          */  
  75.         System.out.println(010);//8  
  76.         System.out.println(10);//10  
  77.     }  
  78.   
  79.     public void testByteToHex() {  
  80.   
  81.         byte negativeByte = -2;  
  82.         byte positiveByte = 2;  
  83.   
  84.         /* toHexString方法类型为int型,所以转Hex前参数会提升成整型后再进行转换,过程如下: 
  85.          * 10000010(原码)->11111110(补码)->11111111 11111111 11111111 11111110(提升) 
  86.          * ->FFFFFFFE(转Hex进制输出) 
  87.          */  
  88.         System.out.println(Integer.toHexString(negativeByte).toUpperCase());// FFFFFFFE  
  89.   
  90.         /* 第一步把-2转成整型: 
  91.          * 10000010(原码)->11111110(补码)->11111111 11111111 11111111 11111110(转整型) 
  92.          * 第二步把 0xFF 前补24个零: 
  93.          * 00000000 00000000 00000000 11111111 
  94.          * 第三步:把第一二步结果进行与位运算: 
  95.          * 00000000 00000000 00000000 11111110 
  96.          * 最后一步:转十六进制结果为 FE  
  97.          */  
  98.         System.out.println(Integer.toHexString(negativeByte & 0xFF).toUpperCase());// FE          
  99.   
  100.         //另一种转换,可以针对负数与正数的byte都可以以完整的单字节输出  
  101.         System.out.println(Integer.toHexString((negativeByte & 0x000000ff) | 0xffffff00)  
  102.                 .substring(6).toUpperCase());//FE  
  103.         System.out.println(Integer.toHexString((positiveByte & 0x000000ff) | 0xffffff00)  
  104.                 .substring(6).toUpperCase());//02  
  105.     }  
  106.   
  107.     /** 
  108.      * 位运算与算术运行中的类型提升机制是一样的 
  109.      */  
  110.     public void testBiteMathematical() {  
  111.         System.out.println(0x8000000000000000L);//-9223372036854775808  
  112.         System.out.println((int) 0x8000000000000000L);//0  
  113.         System.out.println(0x8000000000000010L);//-9223372036854775792  
  114.         System.out.println(0x80000000);//-2147483648   
  115.         System.out.println(0x80000010);//-2147483632   
  116.   
  117.         //0x00000010提升成长整型,最后结果为长整型0x8000000000000010L  
  118.         System.out.println(0x00000010 | 0x8000000000000000L);//-9223372036854775792  
  119.         //0x0010提升成整形,最后结果为整型0x80000010  
  120.         System.out.println(0x0010 | 0x80000000);//-2147483632   
  121.     }  
  122. }  
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:85975次
    • 积分:1114
    • 等级:
    • 排名:千里之外
    • 原创:2篇
    • 转载:167篇
    • 译文:0篇
    • 评论:11条
    最新评论