16进制的字符串转byte[]数组
public class ClientString16 {
@Test
public 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){
// 用字节数组的内容创建一个ByteBuf
ByteBuf 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");//hello
System.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);// 输入两位校验位 结果是B0
System.out.println("非运算符：如果位为0，结果是1，如果位为1，结果是0 "+~Integer.valueOf(result,16));
}
public static void getBytetoString(byte[] bytes1){
// 用字节数组的内容创建一个ByteBuf
ByteBuf 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的十进制是255
String 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};
// 用字节数组的内容创建一个ByteBuf
ByteBuf 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进制字符串=01F10004030601B0
public 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);// 输入两位校验位 结果是B0
System.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的十进制是255
String 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进制的FF
int 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();
}
