java 中各进制之间转换方法

java中十进制、十六进制、二进制、ASCII码是常用的编码方式，在本篇文章中将这些编码的相互转换直接以代码的形式粘贴出来，以供参考。

工具/原料

java JDK

Eclipse

十六进制字符串转十进制

1、param hex 十六进制字符串return 十进制数值

2、public static int hexStringToAlgorism(String hex) {hex = hex.toUpperCase();int max = hex.length();int result = 0;for (int i = max; i > 0; i--) {char c = hex.charAt(i - 1);int algorism = 0;if (c >= '0' && c <= '9') {algorism = c - '0';} else {algorism = c - 55;}result += Math.pow(16, max - i) * algorism;}return result;}

数字字符串转ASCII码字符串

1、param content 字符串return ASCII字符串

2、public static String StringToAsciiString(String content) { String result = ""; int max = content.length(); for (int i = 0; i < max; i++) { char c = content.charAt(i); String b = Integer.toHexString(c); result = result + b; } return result; }

十六进制转字符串

1、param hexString十六进制字符串param encodeType编码类型4：Unicode，2：普通编码return 字符串

2、public static String hexStringToString(String hexString, int encodeType) { String result = ""; int max = hexString.length() / encodeType; for (int i = 0; i < max; i++) { char c = (char) StringUtils.hexStringToAlgorism(hexString.substring(i * encodeType, (i + 1) * encodeType)); result += c; } return result; }

十六转二进制

1、param hex十六进制字符串return 二进制字符串

2、public static String hexStringToBinary(String hex) { hex = hex.toUpperCase(); String result = ""; int max = hex.length(); for (int i = 0; i < max; i++) { char c = hex.charAt(i); switch (c) { case '0': result += "0000"; break; case '1': result += "0001"; break; case '2': result += "0010"; break; case '3': result += "0011"; break; case '4': result += "0100"; break; case '5': result += "0101"; break; case '6': result += "0110"; break; case '7': result += "0111"; break; case '8': result += "1000"; break; case '9': result += "1001"; break; case 'A': result += "1010"; break; case 'B': result += "1011"; break; case 'C': result += "1100"; break; case 'D': result += "1101"; break; case 'E': result += "1110"; break; case 'F': result += "1111"; break; } } return result; }

ASCII码字符串转数字字符串

1、param contentASCII字符串return 字符串

2、public static String AsciiStringToString(String content) { String result = ""; int length = content.length() / 2; for (int i = 0; i < length; i++) { String c = content.substring(i * 2, i * 2 + 2); int a = hexStringToAlgorism(c); char b = (char) a; String d = String.valueOf(b); result += d; } return result; }

将十进制转换为指定长度的十六进制字符串

1、param algorism十进制数字param maxLength 转换后的十六进制字符串长度return String 转换后的十六进制字符串

2、public static String algorismToHEXString(int algorism, int maxLength) { String result = ""; result = Integer.toHexString(algorism); if (result.length() % 2 == 1) { result = "0" + result; } return patchHexString(result.toUpperCase(), maxLength); }

二进制字符串转十进制

1、param binary二进制字符串return 十进制数值

2、public static int binaryToAlgorism(String binary) { int max = binary.length(); int result = 0; for (int i = max; i > 0; i--) { char c = binary.charAt(i - 1); int algorism = c - '0'; result += Math.pow(2, max - i) * algorism; } return result; }

十进制转换为十六进制字符串

1、param algorism int 十进制的数字return String 对应的十六进制字符串

2、public static String algorismToHEXString(int algorism) { String result = ""; result = Integer.toHexString(algorism); if (result.length() % 2 == 1) { result = "0" + result; } result = result.toUpperCase(); return result; }

十六进制字符串转为Byte数组,每两个十六进制字符转为一个Byte

1、param hex 十六进制字符串return byte 转换结果

2、public static byte[] hexStringToByte(String hex) { int max = hex.length() / 2; byte[] bytes = new byte[max]; String binarys = StringUtils.hexStringToBinary(hex); for (int i = 0; i < max; i++) { bytes[i] = (byte) StringUtils.binaryToAlgorism(binarys.substring(i * 8 + 1, (i + 1) * 8)); if (binarys.charAt(8 * i) == '1') { bytes[i] = (byte) (0 - bytes[i]); } } return bytes; }

十六进制串转化为byte数组

1、param hex 十六进制字符串return byte 转换结果

2、public static final byte[] hex2byte(String hex) throws IllegalArgumentException { if (hex.length() % 2 != 0) { throw new IllegalArgumentException(); } char[] arr = hex.toCharArray(); byte[] b = new byte[hex.length() / 2]; for (int i = 0, j = 0, l = hex.length(); i < l; i++, j++) { String swap = "" + arr[i++] + arr[i]; int byteint = Integer.parseInt(swap, 16) & 0xFF; b[j] = new Integer(byteint).byteValue(); } return b; }

字节数组转换为十六进制字符串

1、param b byte[] 需要转换的字节数组return String 十六进制字符串

2、public static final String byte2hex(byte b[]) { if (b == null) { throw new IllegalArgumentException("Argument b ( byte array ) is null! "); } String hs = ""; String stmp = ""; for (int n = 0; n < b.length; n++) { stmp = Integer.toHexString(b[n] & 0xff); if (stmp.length() == 1) { hs = hs + "0" + stmp; } else { hs = hs + stmp; } } return hs.toUpperCase(); }

16进制字符串转换为字符串

1、public static String hexStringToString(String s) { if (s == null || s.equals("")) { return null; } s = s.replace(" ", ""); 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, "gbk"); new String(); } catch (Exception e1) { e1.printStackTrace(); } return s; }

字符串转换为16进制字符串

1、public static String stringToHexString(String s) { if (s == null || s.equals("")) { return null; } String str = ""; byte[] bytes; try { bytes = s.getBytes("gbk");// 先把字符串按gb2312转成byte数组 for (byte b : bytes) {// 循环数组 String changeStr = Integer.toHexString(b).substring(Integer.toHexString(b).length() - 2, Integer.toHexString(b).length()); str = str + changeStr; } } catch (UnsupportedEncodingException e) { // TODO Auto-generated catch block e.printStackTrace(); } return str; }

double转16进制数组

1、public static byte[] doubleToHex(double data, int length) { long longData = Double.doubleToLongBits(data); byte[] returnByte = new byte[length]; if (length > 0) { returnByte[0] = (byte) (longData & 0x000000000000FFL); } else if (length > 1) { returnByte[1] = (byte) ((longData & 0x0000000000FF00L) >> 8); } else if (length > 2) { returnByte[2] = (byte) ((longData & 0x0000000000FF0000L) >> 16); } else if (length > 3) { returnByte[3] = (byte) ((longData & 0x00000000FF000000L) >> 24); } else if (length > 4) { returnByte[4] = (byte) ((longData & 0x000000FF00000000L) >> 32); } else if (length > 5) { returnByte[5] = (byte) ((longData & 0x0000FF0000000000L) >> 40); } else if (length > 6) { returnByte[6] = (byte) ((longData & 0x00FF000000000000L) >> 48); } else if (length > 7) { returnByte[7] = (byte) ((longData & 0xFF00000000000000L) >> 56); } return returnByte; }