当前位置：首页 > news >正文

16进制的字符串转byte[]数组以及将字节数组转换成十六进制的字符串

news 来源：原创 2024/5/17 6:17:26

16进制的字符串转byte[]数组

public class ClientString16 {@Testpublic void get16Str(){String str="48 47 12 00 14 12 16 08 15 0d 30 0f 02 30 30 30 30 30 30 30 30 30 30 00 c2";byte[] bytes = hexStringToByteArray(str);getBytetoString(bytes);//String sendSocket = sendSocket("",bytes,null);//System.out.println("---sendSocket---"+sendSocket);}public static void  getBytetoString(byte[] bytes1){// 用字节数组的内容创建一个ByteBufByteBuf buf = Unpooled.copiedBuffer(bytes1);//将buffer内容转换为多行美化过的十六进制表示的字符串System.out.println(ByteBufUtil.prettyHexDump(buf));}/*** 16进制表示的字符串转换为字节数组** @param hexString 16进制表示的字符串* @return byte[] 字节数组*/public static byte[] hexStringToByteArray(String hexString) {hexString = hexString.replaceAll(" ", "");int len = hexString.length();byte[] bytes = new byte[len / 2];for (int i = 0; i < len; i += 2) {// 两位一组，表示一个字节,把这样表示的16进制字符串，还原成一个字节bytes[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) + Character.digit(hexString.charAt(i + 1), 16));}return bytes;}
}

将字节数组转换成十六进制的字符串

byte[] 转16进制的字符串

public  static  void get() {Socket socket = null;String strReturn = null;try {System.out.println("connecting...");socket = new Socket("localhost",8090);System.out.println("connection success");while (true){// 使用用户名和密码申请授权码(仅使用一次，取得正确授权码后，就不需要了。授权码应保存在磁盘上，供以后登录使用)//String str="48 47 12 00 12 12 16 08 15 0d 30 0f 20 30 30 30 30 30 30 30 30 30 30 20 18 1C 63 FB 2F CF 5B BE 2A D9 A4 0D C2 31 F2 DF 4B FF CF 9C 68 E1 E5 63 EC AD 8F 48 78 D4 E2 89 72";//String str="48 47 12 00 12 12 16 08 1F 0A 03 0F 20 30 30 30 30 30 30 30 30 30 30 20 6F 73 A7 02 9A CC 19 5A 16 0A 56 ED BB 45 EC DC 29 56 8D CB 67 0B D9 93 82 D6 51 F7 8C 85 52 32 B9";//48 47 12 00 12 12 16 08 1F 0A 03 0F 10 30 30 30 30 30 30 30 30 30 30 61 00 61 E8 44 B8 06 8D EE B7 C3 E4 45 01 B7 90 A3 3F D7 68 92 80 A0 16 0F 37 AF 79 EA E3 E8 3A F5 A0 46 ED 10 1A D2 DB 2C 80 00 74 3F 05 9E 66 64 CB 6A D9 E6 A0 B8 4C 39 5D 39 04 1D 37 23 AC 59 30 AB 1B 3F AA C2 CC 9B 81 B5 30 DD BF A7 2A 88 22 2B F1 16 2F BC C9 D7 73 3C 6A 9D 2F 35 09 28 F5 C2//String str="48 47 12 00 97 00 16 09 02 11 21 08 21 30 30 30 30 30 30 30 30 30 30 60 57 08 B5 0D 71 8E 74 94 5E 30 29 15 D1 9A D4 AA C2 FD 1E 53 E9 3A E1 CA F5 CF A2 6A 6A 74 2B 8F 87 B6 DF A1 5B CA 05 03 1F 3F 86 CF 8A 0C 05 85 7D 94 65 DE 12 4A A5 E3 EF 46 CD DE C8 13 5F 4C 17 2C 08 41 8F 31 99 44 55 AA B5 A5 A8 25 2A 8D 97 FC 22 76 11 50 02 67 05 30 D0 1D 5B 51 5A A1 1e";String str="48 47 12 00 04 01 16 09 02 11 38 0d 21 30 30 30 30 30 30 30 30 30 30 60 57 08 B5 0D 71 8E 74 94 5E 30 29 15 D1 9A D4 AA C2 FD 1E 53 E9 3A E1 CA F5 CF A2 6A 6A 74 2B 8F 87 B6 DF A1 5B CA 05 03 1F 3F 86 CF 8A 0C 05 85 7D 94 65 DE 12 4A A5 E3 EF 46 CD DE C8 13 5F 4C 17 2C 08 41 8F 31 99 44 55 AA B5 A5 A8 25 2A 8D 97 FC 22 76 11 50 02 67 05 30 D0 1D 5B 51 5A A1 90";byte[] bytes = hexStringToByteArray(str);OutputStream os = socket.getOutputStream();os.write(bytes);//getBytetoString(bytes);System.out.println("---client send server 输出流-----"+str);//输入流InputStream in=socket.getInputStream();System.out.println("---接收服务器的响应-----");//接收服务器的响应int line = 0;byte[] buf = new byte[1024];//接收收到的数据int len = in.read(buf);//getBytetoString(buf);strReturn= BinaryToHexString(buf);System.out.println(strReturn);//os.close();Thread.sleep(1000);}} catch (Exception e) {e.printStackTrace();} finally {if (socket != null) {try {socket.close();} catch (Exception e) {}}}}/*** 将字节数组转换成十六进制的字符串** @return*/public static String BinaryToHexString(byte[] bytes) {String hexStr = "0123456789ABCDEF";String result = "";String hex = "";for (byte b : bytes) {hex = String.valueOf(hexStr.charAt((b & 0xF0) >> 4));hex += String.valueOf(hexStr.charAt(b & 0x0F));result += hex + " ";}return result;}

16进制直接转换成为字符串

         String s = hexStr2Str("48 65 6C 6C 6F");//helloSystem.out.println(s);public static String hexStr2Str(String hexStr) {char[] hexs = hexStr.toCharArray();byte[] bytes = new byte[hexStr.length() / 2];int n;for (int i = 0; i < bytes.length; i++) {n = HEXMAXSTRING.indexOf(hexs[2 * i]) * 16;n += HEXMAXSTRING.indexOf(hexs[2 * i + 1]);bytes[i] = (byte) (n & 0xff);}return new String(bytes);}

java符号&、| 、~、^、&&、||、!

位逻辑运算符：
&:
位与运算符，只有两个操作数都是true，结果才是true。
| :
位或运算符，只有两个操作数都是false，结果才是false。
~：
位非运算符：如果位为0，结果是1，如果位为1，结果是0.
^:
位异或运算：两个数转为二进制，然后从高位开始比较，如果相同则为0，不相同则为1。位同或运算：两个数转为二进制，然后从高位开始比较，如果相同则为1，不相同则为0。java中并没有同或运算符，可以通过异或转换得到。同或运算 = 异或运算  ^  1逻辑运算符：
&&:
逻辑与运算，也是只有两个操作数都是true，结果才是true。但是如果左边操作数为false，就不计算右边的表达式，直接得出false。类似于短路了右边。
||:
逻辑或运算，也是只有两个操作数都是false，结果才是false。但是如果左边操作数为true，就不计算右边的表达式，直接得出true。类似于短路了右边。
!：
逻辑非运算，对操作数取反。

输入十六进制，输出两位校验位

import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.buffer.Unpooled;public class CalculateCheckDigit {/** 输入十六进制，输出两位校验位 */public static void main(String args[]) {String sHex = "01 F1 00 04 03 06 01 B0";// 输入十六进制//sHex ="12 12 16 08 15 0d 30 0f 20 30 30 30 30 30 30 30 30 30 30 20 18 1C 63 FB 2F CF 5B BE 2A D9 A4 0D C2 31 F2 DF 4B FF CF 9C 68 E1 E5 63 EC AD 8F 48 78 D4 E2 89";//sHex ="18 12 16 08 15 0d 30 0f 05 73 78 78 61 30 30 30 30 30 31 00";byte[] bytes = hexStringToByteArray(sHex);getBytetoString(bytes);sHex = sHex.replace(" ", "");// 去掉中间空格String result = makeCheckSum(sHex);// 计算并获取校验位System.out.println(result);// 输入两位校验位 结果是B0System.out.println("非运算符：如果位为0，结果是1，如果位为1，结果是0 "+~Integer.valueOf(result,16));}public static void  getBytetoString(byte[] bytes1){// 用字节数组的内容创建一个ByteBufByteBuf buf = Unpooled.copiedBuffer(bytes1);//将buffer内容转换为多行美化过的十六进制表示的字符串System.out.println(ByteBufUtil.prettyHexDump(buf));}public static byte[] hexStringToByteArray(String hexString) {hexString = hexString.replaceAll(" ", "");int len = hexString.length();byte[] bytes = new byte[len / 2];for (int i = 0; i < len; i += 2) {// 两位一组，表示一个字节,把这样表示的16进制字符串，还原成一个字节bytes[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) + Character.digit(hexString.charAt(i + 1), 16));}return bytes;}/** 计算校验位 ，返回十六进制校验位 */private static String makeCheckSum(String data) {int dSum = 0;int length = data.length();int index = 0;// 遍历十六进制，并计算总和while (index < length) {String s = data.substring(index, index + 2); // 截取2位字符dSum += Integer.parseInt(s, 16); // 十六进制转成十进制 , 并计算十进制的总和index = index + 2;}int mod = dSum % 256; // 用256取余，十六进制最大是FF，FF的十进制是255String checkSumHex = Integer.toHexString(mod); // 余数转成十六进制length = checkSumHex.length();if (length < 2) {checkSumHex = "0" + checkSumHex;  // 校验位不足两位的，在前面补0}return checkSumHex;}
}

将byte数组转成16进制字符串=01F10004030601B0

String sHex = "01 F1 00 04 03 06 01 B0";// 输入十六进制//sHex ="12 12 16 08 15 0d 30 0f 20 30 30 30 30 30 30 30 30 30 30 20 18 1C 63 FB 2F CF 5B BE 2A D9 A4 0D C2 31 F2 DF 4B FF CF 9C 68 E1 E5 63 EC AD 8F 48 78 D4 E2 89";//sHex ="18 12 16 08 15 0d 30 0f 05 73 78 78 61 30 30 30 30 30 31 00";byte[] bytes = hexStringToByteArray(sHex);String hexDump = ByteBufUtil.hexDump(bytes);System.out.println("将字节数组的内容转换为十六进制表示的字符串==>>"+hexDump);//用ByteBufUtil的hexDump(ByteBuf buffer)函数将ByteBuf 的内容转换为十六进制表示的字符串byte[] b1 = new byte[] {0x68, 0x16, 0x03, 0x04, (byte)0xae};// 用字节数组的内容创建一个ByteBufByteBuf buf = Unpooled.copiedBuffer(b1);//将buffer内容转换为多行美化过的十六进制表示的字符串System.out.println(ByteBufUtil.prettyHexDump(buf));String hexDump1 = ByteBufUtil.hexDump(buf);System.out.println("--将ByteBuf 的内容转换为十六进制表示的字符串--"+hexDump1);

  String sHex = "01 F1 00 04 03 06 01 B0";// 输入十六进制//sHex ="12 12 16 08 15 0d 30 0f 20 30 30 30 30 30 30 30 30 30 30 20 18 1C 63 FB 2F CF 5B BE 2A D9 A4 0D C2 31 F2 DF 4B FF CF 9C 68 E1 E5 63 EC AD 8F 48 78 D4 E2 89";//sHex ="18 12 16 08 15 0d 30 0f 05 73 78 78 61 30 30 30 30 30 31 00";byte[] bytes = hexStringToByteArray(sHex);getBytetoString(bytes);String s = bytesToHexFun1(bytes);//将byte数组转成16进制字符串//将byte数组转成16进制字符串=01F10004030601B0public static String bytesToHexFun1(byte[] bytes) {char[] HEX_CHAR = {'0', '1', '2', '3', '4', '5','6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};// 一个byte为8位，可用两个十六进制位标识char[] buf = new char[bytes.length * 2];int a = 0;int index = 0;for(byte b : bytes) { // 使用除与取余进行转换if(b < 0) {a = 256 + b;} else {a = b;}buf[index++] = HEX_CHAR[a / 16];buf[index++] = HEX_CHAR[a % 16];}return new String(buf);}

输入十六进制，输出两位校验位

public class CalculateCheckDigit {/** 输入十六进制，输出两位校验位 */public static void main(String args[]) {//String sHex = "01 F1 00 04 03 06 01 B0";// 输入十六进制//String sHex ="12 12 16 08 15 0d 30 0f 20 30 30 30 30 30 30 30 30 30 30 20 18 1C 63 FB 2F CF 5B BE 2A D9 A4 0D C2 31 F2 DF 4B FF CF 9C 68 E1 E5 63 EC AD 8F 48 78 D4 E2 89";String sHex ="18 12 16 08 15 0d 30 0f 05 73 78 78 61 30 30 30 30 30 31 00";sHex = sHex.replace(" ", "");// 去掉中间空格String result = makeCheckSum(sHex);// 计算并获取校验位System.out.println(result);// 输入两位校验位 结果是B0System.out.println(~Integer.valueOf(result,16));}/** 计算校验位 ，返回十六进制校验位 */private static String makeCheckSum(String data) {int dSum = 0;int length = data.length();int index = 0;// 遍历十六进制，并计算总和while (index < length) {String s = data.substring(index, index + 2); // 截取2位字符dSum += Integer.parseInt(s, 16); // 十六进制转成十进制 , 并计算十进制的总和index = index + 2;}int mod = dSum % 256; // 用256取余，十六进制最大是FF，FF的十进制是255String checkSumHex = Integer.toHexString(mod); // 余数转成十六进制length = checkSumHex.length();if (length < 2) {checkSumHex = "0" + checkSumHex;  // 校验位不足两位的，在前面补0}return checkSumHex;}
}

累加和校验，并取反

  String sHex = "01 F1 00 04 03 06 01 B0";// 输入十六进制String s = makeCheckSum1(sHex);System.out.println("s-->>"+s);String and = Integer.toHexString((Integer.valueOf(s, 16) + 1));System.out.println(and);/*** 累加和校验，并取反*/public static String makeCheckSum1(String data) {if (data == null || data.equals("")) {return "";}int total = 0;int len = data.length();int num = 0;while (num < len) {String s = data.substring(num, num + 2);total += Integer.parseInt(s, 16);num = num + 2;}//用256求余最大是255，即16进制的FFint mod = total % 256;if (mod == 0) {return "FF";} else {String hex = Integer.toHexString(mod).toUpperCase();hex = parseHex2Opposite(hex);return hex;}}/*** 取反*/public static String parseHex2Opposite(String str) {String hex;//十六进制转成二进制byte[] er = parseHexStr2Byte(str);//取反byte erBefore[] = new byte[er.length];for (int i = 0; i < er.length; i++) {erBefore[i] = (byte) ~er[i];}//二进制转成十六进制hex = parseByte2HexStr(erBefore);// 如果不够校验位的长度，补0,这里用的是两位校验hex = (hex.length() < 2 ? "0" + hex : hex);return hex;}/*** 将十六进制转换为二进制*/public static byte[] parseHexStr2Byte(String hexStr) {if (hexStr.length() < 1) {return null;}byte[] result = new byte[hexStr.length() / 2];for (int i = 0; i < hexStr.length() / 2; i++) {int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);result[i] = (byte) (high * 16 + low);}return result;}/*** 将二进制转换成十六进制*/public static String parseByte2HexStr(byte buf[]) {StringBuffer sb = new StringBuffer();for (int i = 0; i < buf.length; i++) {String hex = Integer.toHexString(buf[i] & 0xFF);if (hex.length() == 1) {hex = '0' + hex;}sb.append(hex.toUpperCase());}return sb.toString();}