public class DigitalTrans {
/**
* 数字字符串转ASCII码字符串
*
* @param String
* 字符串
* @return ASCII字符串
*/
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;
}
/**
* 十六进制转字符串
*
* @param hexString
* 十六进制字符串
* @param encodeType
* 编码类型4：Unicode，2：普通编码
* @return 字符串
*/
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) DigitalTrans.hexStringToAlgorism(hexString
.substring(i * encodeType, (i + 1) * encodeType));
result += c;
}
return result;
}
/**
* 十六进制字符串装十进制
*
* @param hex
* 十六进制字符串
* @return 十进制数值
*/
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;
}
/**
* 十六转二进制
*
* @param hex
* 十六进制字符串
* @return 二进制字符串
*/
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码字符串转数字字符串
*
* @param String
* ASCII字符串
* @return 字符串
*/
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;
}
/**
* 将十进制转换为指定长度的十六进制字符串
*
* @param algorism
* int 十进制数字
* @param maxLength
* int 转换后的十六进制字符串长度
* @return String 转换后的十六进制字符串
*/
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);
}
/**
* 字节数组转为普通字符串（ASCII对应的字符）
*
* @param bytearray
* byte[]
* @return String
*/
public static String bytetoString(byte[] bytearray) {
String result = "";
char temp;
int length = bytearray.length;
for (int i = 0; i < length; i++) {
temp = (char) bytearray[i];
result += temp;
}
return result;
}
/**
* 二进制字符串转十进制
*
* @param binary
* 二进制字符串
* @return 十进制数值
*/
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;
}
/**
* 十进制转换为十六进制字符串
*
* @param algorism
* int 十进制的数字
* @return String 对应的十六进制字符串
*/
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;
}
/**
* HEX字符串前补0，主要用于长度位数不足。
*
* @param str
* String 需要补充长度的十六进制字符串
* @param maxLength
* int 补充后十六进制字符串的长度
* @return 补充结果
*/
static public String patchHexString(String str, int maxLength) {
String temp = "";
for (int i = 0; i < maxLength - str.length(); i++) {
temp = "0" + temp;
}
str = (temp + str).substring(0, maxLength);
return str;
}
/**
* 将一个字符串转换为int
*
* @param s
* String 要转换的字符串
* @param defaultInt
* int 如果出现异常,默认返回的数字
* @param radix
* int 要转换的字符串是什么进制的,如16 8 10.
* @return int 转换后的数字
*/
public static int parseToInt(String s, int defaultInt, int radix) {
int i = 0;
try {
i = Integer.parseInt(s, radix);
} catch (NumberFormatException ex) {
i = defaultInt;
}
return i;
}
/**
* 将一个十进制形式的数字字符串转换为int
*
* @param s
* String 要转换的字符串
* @param defaultInt
* int 如果出现异常,默认返回的数字
* @return int 转换后的数字
*/
public static int parseToInt(String s, int defaultInt) {
int i = 0;
try {
i = Integer.parseInt(s);
} catch (NumberFormatException ex) {
i = defaultInt;
}
return i;
}
/**
* 十六进制字符串转为Byte数组,每两个十六进制字符转为一个Byte
*
* @param hex
* 十六进制字符串
* @return byte 转换结果
*/
public static byte[] hexStringToByte(String hex) {
int max = hex.length() / 2;
byte[] bytes = new byte[max];
String binarys = DigitalTrans.hexStringToBinary(hex);
for (int i = 0; i < max; i++) {
bytes[i] = (byte) DigitalTrans.binaryToAlgorism(binarys.substring(
i * 8 + 1, (i + 1) * 8));
if (binarys.charAt(8 * i) == '1') {
bytes[i] = (byte) (0 - bytes[i]);
}
}
return bytes;
}
/**
* 十六进制串转化为byte数组
*
* @return the array of byte
*/
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;
}
/**
* 字节数组转换为十六进制字符串
*
* @param b
* byte[] 需要转换的字节数组
* @return String 十六进制字符串
*/
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();
}
}
分享到：
相关推荐
在Android开发中，有时我们需要将字节数组（byte array）转换为十六进制字符串，以便于数据存储、传输或调试。这是因为字节数组是二进制数据，而十六进制字符串则是一种人类可读的表示方式。下面我们将详细讨论如何...
6. **ASCII码转2进制/16进制**：先将ASCII码转换为十进制，然后转换为二进制或十六进制。 在MFC环境中，你可以创建一个对话框类（`CDialogEx`），并在其中添加控件如编辑框和按钮，用于输入和显示转换结果。当用户...
`substring`方法用于从原始字符串中提取出每两个字符（一个字节的十六进制表示），并使用`Integer.parseInt`将其转换为十进制整数，进而得到原始字节。 在处理编码问题时，了解不同编码格式的特点和差异至关重要。...
对于其他进制之间的转换，例如二进制、八进制、十进制和十六进制之间的转换，我们可以利用以下策略： 1. **二进制与十进制**： - 二进制转十进制：使用`BinaryToDecimal()`函数。 - 十进制转二进制：可以使用`...
十六进制转ASCII其实与上面的“十六进制转字符串”部分相似，因为ASCII编码本身就是用十进制或十六进制表示的。上面的`hex_to_ascii`函数已经实现了这个功能，它将十六进制数字转换为对应的ASCII字符。 三、字符串...
`std::bitset`类可以方便地进行二进制与其它进制之间的转换，`std::stringstream`或`std::hex`、`std::dec`可以处理十进制与十六进制的转换。至于ASCII码，可以直接使用字符与整型间的隐式转换，或者使用`char`和`...
1. **字符转ASCII码**：每个字符串中的字符都有对应的ASCII码，这是基于十进制的数值。Delphi中，可以使用`Ord()`函数获取字符的ASCII值。 2. **ASCII码转二进制**：将ASCII码转换为二进制表示。可以逐位提取ASCII...
这个类可以将浮点数转换为字节数组，然后可以将字节数组转换为十六进制字符串。需要注意的是，浮点数的转换可能涉及精度损失和平台依赖性。 除了整数和浮点数，C#还支持字符串到十六进制和十六进制到字符串的转换。...
在Linux C环境中，十六进制（Hexadecimal）与字符串（String）之间的转换是常见的编程需求。十六进制是一种逢16进1的进位制，通常用于表示二进制数据，而字符串则是一系列字符的集合。理解这两种类型之间的转换对于...
在计算机科学中，数据通常以不同的进制表示，如二进制、八进制、十进制和十六进制。十六进制（Hexadecimal）是一种逢16进1的计数制，它使用16个符号（0-9 和 A-F）来表示数值。而二进制（Binary）是计算机的基础，...
3. **16进制字符串转换**：编写一个函数，将16进制字符串转换为字节数组。可以使用StrToIntHex函数或者遍历字符串并逐个转换每个字符。例如： ```delphi function HexStringToBytes(const HexStr: string): TBytes...
每个ASCII码值都是一个介于0到255之间的十进制数，转换后的十六进制值长度固定为2位。 ### 代码实现分析 #### `charConvertHexChar` 函数 该函数负责将一个字符转换为其对应的十六进制数值。通过判断字符的范围，...
在编程领域，转换数字的...理解这些概念并能熟练应用对于进行二进制、八进制、十进制和十六进制之间的转换至关重要，这对于编写处理数字数据的VB程序非常有用。希望这些信息对你有所帮助，祝你在编程学习路上一帆风顺！
例如，在Python中，`ord()`函数可以将ASCII字符转换为其对应的十进制数值，`hex()`函数则可以将十进制数转换为十六进制字符串；相反，`chr()`函数可以将ASCII码值转换回对应的字符，`int()`函数可以将十六进制字符串...
进制转换在计算机网络中也扮演着重要角色，如IP地址的表示（通常使用点分十进制表示，但实际上是个32位二进制数），MAC地址（通常用冒号分隔的十六进制表示）以及URL编码（使用百分号%后跟两位十六进制数来表示非...
它基于16个符号（0-9及A-F），每个位能表示16种可能的值，因此每两位十六进制数对应一个八位的二进制数，也就是一个字节。字符串（String）则是由零个或多个字符组成的序列，通常用于存储文本信息。在C++中，处理这...
在二进制文件中，每个字节都对应一个0到255之间的十进制数字，可以用十六进制表示。你可以通过遍历文件的字节并比较它们的值来实现。例如，寻找十六进制值0x41（'A'的ASCII码）： ```python with open('binary_file...
在进制转换方面，LabVIEW提供了丰富的函数库，可以进行二进制、八进制、十进制和十六进制之间的转换。这些转换函数可以帮助开发人员在不同的表示形式间自由切换，以适应不同的需求。 “labview character string....
在计算机科学中，我们经常需要在二进制、八进制、十进制和十六进制之间进行转换。每种进制都有其特定的基数，即它包含的数字数量。例如，二进制基数是2，只包含0和1；八进制基数是8，包含0-7；十进制基数是10，包含0...
一个十六进制数可以表示0到255之间的十进制数，这与ASCII码中的所有字符对应。ASCII码的前32个字符是非打印字符，33到126是可打印的字符，包括字母、数字、标点符号等。 在C#中，我们可以使用`Convert.ToInt32`函数...