Java中进制转换

// 十进制转化为十六进制，结果为f。
Integer.toHexString(15); 
// 十六进制转化为十进制，结果15。
Integer.parseInt("f",16); 

来自：http://jiangzhengjun.iteye.com/blog/506041

为了显示一个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. } 
123.