有趣的地方

有趣的地方

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

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();
    }

发表评论:

Powered By Z-BlogPHP 1.7.3

© 2018-2020 有趣的地方 粤ICP备18140861号-1 网站地图