java 中各进制之间转换方法
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;
}
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;
}
1、param content ASCII字符串
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;
}
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;
}
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();
}
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;
}
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;
}
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;
}