java 中进制的转换, Byte 与 16 进制的转换方法
这里有新鲜出炉的 Java 并发编程示例, 程序狗速度看过来!
Java 程序设计语言
java 是一种可以撰写跨平台应用软件的面向对象的程序设计语言, 是由 Sun Microsystems 公司于 1995 年 5 月推出的 Java 程序设计语言和 Java 平台 (即 JavaEE(j2ee), JavaME(j2me), JavaSE(j2se)) 的总称
下面小编就为大家带来一篇 java 中进制的转换, Byte 与 16 进制的转换方法小编觉得挺不错的, 现在就分享给大家, 也给大家做个参考一起跟随小编过来看看吧
java 中对于进制的转换有很多方式, 其中对于常见的基本的二进制 八进制 十进制 十六进制等的转换有对于的包装类实现, 不需要通过二外的算法来进行实现, 具体如下:
首先关于最简单的二进制转换的方法有:
十进制转成十六进制:
String Integer.toHexString(int i)
十进制转成八进制
String Integer.toOctalString(int i)
十进制转成二进制
String Integer.toBinaryString(int i)
十六进制转成十进制
Integer.valueOf("FFFF",16).toString() // 不能处理带前缀的情况 0x
八进制转成十进制
Integer.valueOf("76",8).toString() // 前缀 0 可以被处理
二进制转十进制
Integer.valueOf("0101",2).toString()
有什么方法可以直接将 2,8,16 进制直接转换为 10 进制的吗 ?
java.lang.Integer 类
parseInt(String s, int radix)
使用第二个参数指定的基数, 将字符串参数解析为有符号的整数
- examples from jdk:
- parseInt("0", 10) returns 0
- parseInt("473", 10) returns 473
- parseInt("-0", 10) returns 0
- parseInt("-FF", 16) returns -255
- parseInt("1100110", 2) returns 102
- parseInt("2147483647", 10) returns 2147483647
- parseInt("-2147483648", 10) returns -2147483648
- parseInt("2147483648", 10)throwsa NumberFormatException
- parseInt("99",throwsa NumberFormatException
- parseInt("Kona", 10)throwsa NumberFormatException
- parseInt("Kona", 27)returns 411787
进制转换如何写 (二, 八, 十六) 不用算法
- Integer.toBinaryString
- Integer.toOctalString
- Integer.toHexString
然后是介绍 java 中的 byte 与十六进制数的转换
原理分析:
Java 中的 byte 是由 8 个 bit 组成的, 而 16 进制即 16 中状态, 它是由 4 个 bit 来表示的, 因为 24=16 所以我们可以把一个 byte 转换成两个用 16 进制字符, 即把高 4 位和低 4 位转换成相应的 16 进制字符, 并组合这两个 16 进制字符串, 从而得到 byte 的 16 进制字符串同理, 相反的转换也是将两个 16 进制字符转换成一个 byte
在 Java 中字节与十六进制的相互转换主要思想有两点:
1 二进制字节转十六进制时, 将字节高位与 0xF0 做 "&" 操作, 然后再左移 4 位, 得到字节高位的十六进制 A; 将字节低位与 0x0F 做 "&" 操作, 得到低位的十六进制 B, 将两个十六进制数拼装到一块 AB 就是该字节的十六进制表示
2 十六进制转二进制字节时, 将十六进制字符对应的十进制数字右移动 4 为, 得到字节高位 A; 将字节低位的十六进制字符对应的十进制数字 B 与 A 做 "|" 运算, 即可得到十六进制的二进制字节表示
其中一种转换的函数如下:
- /**
- *
- * @param bytes
- * @return 将二进制转换为十六进制字符输出
- */ </span> private static String hexStr = "0123456789ABCDEF"; // 全局
- public static String BinaryToHexString(byte[] bytes){
- String result = "";
- String hex = "";
- for(int i=0;i<bytes.length;i++){
- // 字节高 4 位
- <strong>hex = String.valueOf(hexStr.charAt((bytes[i]&0xF0)>>4)); </strong>
- // 字节低 4 位
- <strong>hex += String.valueOf(hexStr.charAt(bytes[i]&0x0F)); </strong>
- result +=hex;
- }
- return result;
- }
- /**
- *
- * @param hexString
- * @return 将十六进制转换为字节数组
- */
- public static byte[] HexStringToBinary(String hexString){
- //hexString 的长度对 2 取整, 作为 bytes 的长度
- int len = hexString.length()/2;
- byte[] bytes = new byte[len];
- byte high = 0;// 字节高四位
- byte low = 0;// 字节低四位
- for(int i=0;i<len;i++){
- // 右移四位得到高位
- high = (byte)((hexStr.indexOf(hexString.charAt(2*i)))<<4);
- low = (byte)hexStr.indexOf(hexString.charAt(2*i+1));
- bytes[i] = (byte) (high|low);// 高地位做或运算
- }
- return bytes;
- }
- }
还有一种类似的方法:
<span style="font-size:14px;">* Convert byte[] to hex string. 这里我们可以将 byte 转换成 int, 然后利用 Integer.toHexString(int)来转换成 16 进制字符串
- * @param src byte[] data * @
- return hex string * /
- public static String bytesToHexString(byte[] src){
- StringBuilder stringBuilder = new StringBuilder("");
- if (src == null || src.length <= 0) {
- return null;
- }
- for (int i = 0; i < src.length; i++) {
- int v = src[i] & 0xFF;
- String hv = Integer.toHexString(v);
- if (hv.length() < 2) {
- stringBuilder.append(0);
- }
- stringBuilder.append(hv);
- }
- return stringBuilder.toString();
- }
- / * **Convert hex string to byte[] * @param hexString the hex string * @
- return byte[] * /
- public static byte[] hexStringToBytes(String hexString) {
- if (hexString == null || hexString.equals("")) {
- return null;
- }
- hexString = hexString.toUpperCase();
- int length = hexString.length() /2;
- char[] hexChars = hexString.toCharArray();
- byte[] d = new byte[length];
- for (int i = 0; i < length; i++) {
- int pos = i * 2;
- d[i] = (byte)(charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
- }
- return d;
- }
- /**
- * Convert char to byte
- * @param c char
- * @return byte
- */
- private byte charToByte(char c) {
- return (byte)"0123456789ABCDEF".indexOf(c);
- } < /span>/
两种方式类似, 这里注意下
上面是将 byte[]转化十六进制的字符串, 注意这里 b[ i ] & 0xFF 将一个 byte 和 0xFF 进行了与运算, 然后使用 Integer.toHexString 取得了十六进制字符串, 可以看出
b[ i ] & 0xFF 运算后得出的仍然是个 int, 那么为何要和 0xFF 进行与运算呢? 直接 Integer.toHexString(b[ i ]);, 将 byte 强转为 int 不行吗? 答案是不行的.
其原因在于:
1.byte 的大小为 8bits 而 int 的大小为 32bits
2.java 的二进制采用的是补码形式
所以与负数 & 的时候负数会自动给补码补位 1, 这样就会有误差
而 0xff 默认是整形, 所以, 一个 byte 跟 0xff 相与会先将那个 byte 转化成整形运算, 这样, 结果中的高的 24 个比特就总会被清 0, 于是结果总是我们想要的
还有一些网上总结的方法:
字符串转换成十六进制字符串方法 1:
- /**
- * 字符串转换成十六进制字符串
- */
- public static String str2HexStr(String str) {
- char[] chars = "0123456789ABCDEF".toCharArray();
- StringBuilder sb = new StringBuilder("");
- byte[] bs = str.getBytes();
- int bit;
- for (int i = 0; i < bs.length; i++) {
- bit = (bs[i] & 0x0f0) >> 4;
- sb.append(chars[bit]);
- bit = bs[i] & 0x0f;
- sb.append(chars[bit]);
- }
- return sb.toString();
- }
十六进制字符串转换成为数组方法 1:
- /**
- * 把 16 进制字符串转换成字节数组
- * @param hexString
- * @return byte[]
- */
- public static byte[] hexStringToByte(String hex) {
- int len = (hex.length() / 2);
- byte[] result = new byte[len];
- char[] achar = hex.toCharArray();
- for (int i = 0; i < len; i++) {
- int pos = i * 2;
- result[i] = (byte)(toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
- }
- return result;
- }
- private static int toByte(char c) {
- byte b = (byte)"0123456789ABCDEF".indexOf(c);
- return b;
- }
数组转换成十六进制字符串方法 1:
- /**
- * 数组转换成十六进制字符串
- * @param byte[]
- * @return HexString
- */
- public static final String bytesToHexString(byte[] bArray) {
- StringBuffer sb = new StringBuffer(bArray.length);
- String sTemp;
- for (int i = 0; i < bArray.length; i++) {
- sTemp = Integer.toHexString(0xFF & bArray[i]);
- if (sTemp.length() < 2) sb.append(0);
- sb.append(sTemp.toUpperCase());
- }
- return sb.toString();
- }
byte[]数组转换成十六进制字符串方法 2:
- /**
- * 数组转成十六进制字符串
- * @param byte[]
- * @return HexString
- */
- public static String toHexString1(byte[] b) {
- StringBuffer buffer = new StringBuffer();
- for (int i = 0; i < b.length; ++i) {
- buffer.append(toHexString1(b[i]));
- }
- return buffer.toString();
- }
- public static String toHexString1(byte b) {
- String s = Integer.toHexString(b & 0xFF);
- if (s.length() == 1) {
- return "0" + s;
- } else {
- return s;
- }
- }
十六进制字符串转换字符串方法 1:
- /**
- * 十六进制字符串转换成字符串
- * @param hexString
- * @return String
- */
- public static String hexStr2Str(String hexStr) {
- String str = "0123456789ABCDEF";
- char[] hexs = hexStr.toCharArray();
- byte[] bytes = new byte[hexStr.length() / 2];
- int n;
- for (int i = 0; i < bytes.length; i++) {
- n = str.indexOf(hexs[2 * i]) * 16;
- n += str.indexOf(hexs[2 * i + 1]);
- bytes[i] = (byte)(n & 0xff);
- }
- return new String(bytes);
- }
十六进制字符串转换字符串方法 2:
- /**
- * 十六进制字符串转换字符串
- * @param HexString
- * @return String
- */
- public static String toStringHex(String s) {
- byte[] baKeyword = new byte[s.length() / 2];
- for (int i = 0; i < baKeyword.length; i++) {
- try {
- baKeyword[i] = (byte)(0xff & Integer.parseInt(s.substring(i * 2, i * 2 + 2), 16));
- } catch(Exception e) {
- e.printStackTrace();
- }
- }
- try {
- s = new String(baKeyword, "utf-8"); // UTF-16le:Not
- } catch(Exception e1) {
- e1.printStackTrace();
- }
- return s;
- }
来源: http://www.phperz.com/article/18/0209/359397.html