有关16进制转换10进制

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

byteVar & 0x000000FF的作用是，如果byteVar

是负数，则会清除前面24个零，正的byte整型不受影响。(...) |

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

Java代码 1.2.3.4.5.6.

import junit.framework.TestCase;

public class Hex extends TestCase {

public void testPositiveIntToHex() {

//如果正数小于15时，只输入一位，而不是按我们想像的两位标准十六进制输出显示的，后面解决这个问题

7. System.out.println(Integer.toHexString( 2 )); //2

8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37. System.out.println(Integer.toHexString( 15 )); //f System.out.println(Integer.toHexString( 16 )); //10 System.out.println(Integer.valueOf( \"F\" , 16 )); //16 }

/*

* Integer.valueOf()实质上调用的是Integer.parseInt()来完成的，所以 * Integer.parseInt()与Integer.valueOf()功能是一样的，只是返回值不 * 一样而已 */

public void testNegativeIntToHex() {

//负整数时，前面输入了多余的 FF ，没有去掉前面多余的 FF，按并双字节形式输出

System.out.println(Integer.toHexString(- 2 ).toUpperCase()); //FFFFFFFE

//实质上0xFF会像转换成0x000000FF后再进行位运算 System.out.println(Integer.toHexString(- 2 & 0xFF ).toUpperCase()); //FE

System.out.println(Integer.toHexString(- 2 & 0x000000FF ).toUpperCase()); //FE

//注，FE输出时不会为-2，因为此时不会把FE看成负数，valueOf会把所有数字串看成正的

System.out.println(Integer.valueOf( \"FE\" , 16 )); //254 //如果要输出-2，只能按以下形式输出

System.out.println(Integer.valueOf( \"-2\" , 16 )); //-2

//所以要把 FE 看成负的话，只能在前面加上负号，但是这里输出还不是-2，

//而是先计算Integer.valueOf(\"FE\ System.out.println(Integer.valueOf( \"-FE\" , 16 )); //-254

/* 所以如果要输入某个负数，我们只能先求出该数的绝对值的原码十六进制，再在前面加上负号，

* 例如求表示-128，则先对绝对值128求十六进制 80，再在前面加上负号 -80

*/

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\ 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\

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. }

出处： http://jiangzhengjun.javaeye.com/blog/506041

Powered by TCPDF (www.tcpdf.org)