| New file |
| | |
|---|
| | | package com.genersoft.iot.vmp.netty.util; |
|---|
| | | |
|---|
| | | |
|---|
| | | import java.nio.ByteBuffer; |
|---|
| | | |
|---|
| | | import static com.genersoft.iot.vmp.netty.config.MyDecoder.hexToByte; |
|---|
| | | import static com.genersoft.iot.vmp.netty.config.MyDecoder.hexTohort; |
|---|
| | | |
|---|
| | | public class Hex { |
|---|
| | | /** |
|---|
| | | * 用于建立十六进制字符的输出的小写字符数组 |
|---|
| | | */ |
|---|
| | | private static final char[] DIGITS_LOWER = {'0', '1', '2', '3', '4', '5', |
|---|
| | | '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 用于建立十六进制字符的输出的大写字符数组 |
|---|
| | | */ |
|---|
| | | private static final char[] DIGITS_UPPER = {'0', '1', '2', '3', '4', '5', |
|---|
| | | '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; |
|---|
| | | |
|---|
| | | |
|---|
| | | private static ByteBuffer buffer = ByteBuffer.allocate(8); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 字符串转换成十六进制字符串 |
|---|
| | | * |
|---|
| | | * @param str 待转换的ASCII字符串 |
|---|
| | | * @return String 每个Byte之间空格分隔，如: [61 6C 6B] |
|---|
| | | */ |
|---|
| | | public static String str2HexStr(String str) { |
|---|
| | | |
|---|
| | | char[] chars = "0123456789ABCDEF".toCharArray(); |
|---|
| | | StringBuilder sb = new StringBuilder(""); |
|---|
| | | byte[] bs = str.getBytes(); |
|---|
| | | int bit; |
|---|
| | | |
|---|
| | | for (int i = 0; i < bs.length; i++) { |
|---|
| | | bit = (bs[i] & 0x0f0) >> 4; |
|---|
| | | sb.append(chars[bit]); |
|---|
| | | bit = bs[i] & 0x0f; |
|---|
| | | sb.append(chars[bit]); |
|---|
| | | sb.append(' '); |
|---|
| | | } |
|---|
| | | return sb.toString().trim(); |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 十六进制转换字符串 |
|---|
| | | * |
|---|
| | | * @param hexStr Byte字符串(Byte之间无分隔符 如:[616C6B]) |
|---|
| | | * @return String 对应的字符串 |
|---|
| | | */ |
|---|
| | | public static String hexStr2Str(String hexStr) { |
|---|
| | | String str = "0123456789ABCDEF"; |
|---|
| | | char[] hexs = hexStr.toCharArray(); |
|---|
| | | byte[] bytes = new byte[hexStr.length() / 2]; |
|---|
| | | int n; |
|---|
| | | |
|---|
| | | for (int i = 0; i < bytes.length; i++) { |
|---|
| | | n = str.indexOf(hexs[2 * i]) * 16; |
|---|
| | | n += str.indexOf(hexs[2 * i + 1]); |
|---|
| | | bytes[i] = (byte) (n & 0xff); |
|---|
| | | } |
|---|
| | | return new String(bytes); |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * bytes转换成十六进制字符串 |
|---|
| | | * |
|---|
| | | * @param b byte数组 |
|---|
| | | * @return String 每个Byte值之间空格分隔 |
|---|
| | | */ |
|---|
| | | public static String byte2HexStr(byte[] b) { |
|---|
| | | String stmp = ""; |
|---|
| | | StringBuilder sb = new StringBuilder(""); |
|---|
| | | for (int n = 0; n < b.length; n++) { |
|---|
| | | stmp = Integer.toHexString(b[n] & 0xFF); |
|---|
| | | sb.append((stmp.length() == 1) ? "0" + stmp : stmp); |
|---|
| | | // sb.append(" "); |
|---|
| | | } |
|---|
| | | return sb.toString().toUpperCase().trim(); |
|---|
| | | } |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * bytes字符串转换为Byte值 |
|---|
| | | * |
|---|
| | | * @param src Byte字符串，每个Byte之间没有分隔符 |
|---|
| | | * @return byte[] |
|---|
| | | */ |
|---|
| | | public static byte[] hexStr2Bytes(String src) { |
|---|
| | | int m = 0, n = 0; |
|---|
| | | int l = src.length() / 2; |
|---|
| | | System.out.println(l); |
|---|
| | | byte[] ret = new byte[l]; |
|---|
| | | for (int i = 0; i < l; i++) { |
|---|
| | | m = i * 2 + 1; |
|---|
| | | n = m + 1; |
|---|
| | | String tmp = "0x" + src.substring(i * 2, m) + src.substring(m, n); |
|---|
| | | ret[i] = Byte.decode(tmp); |
|---|
| | | } |
|---|
| | | return ret; |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * bytes字符串转换为Byte值 |
|---|
| | | * |
|---|
| | | * @param hexString |
|---|
| | | * @return |
|---|
| | | */ |
|---|
| | | public static byte[] hexToBytes(String hexString) { |
|---|
| | | if (hexString == null || hexString.equals("")) { |
|---|
| | | return null; |
|---|
| | | } |
|---|
| | | |
|---|
| | | int length = hexString.length() / 2; |
|---|
| | | char[] hexChars = hexString.toCharArray(); |
|---|
| | | byte[] bytes = new byte[length]; |
|---|
| | | // String hexDigits = "0123456789abcdefABCDEF"; |
|---|
| | | String hexDigits = "0123456789abcdef"; |
|---|
| | | for (int i = 0; i < length; i++) { |
|---|
| | | int pos = i * 2; // 两个字符对应一个byte |
|---|
| | | int h = hexDigits.indexOf(hexChars[pos]) << 4; // 注1 |
|---|
| | | int l = hexDigits.indexOf(hexChars[pos + 1]); // 注2 |
|---|
| | | if (h == -1 || l == -1) { // 非16进制字符 |
|---|
| | | return null; |
|---|
| | | } |
|---|
| | | bytes[i] = (byte) (h | l); |
|---|
| | | } |
|---|
| | | return bytes; |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * String的字符串转换成unicode的String |
|---|
| | | * |
|---|
| | | * @param strText 全角字符串 |
|---|
| | | * @return String 每个unicode之间无分隔符 |
|---|
| | | * @throws Exception |
|---|
| | | */ |
|---|
| | | public static String strToUnicode(String strText) throws Exception { |
|---|
| | | char c; |
|---|
| | | StringBuilder str = new StringBuilder(); |
|---|
| | | int intAsc; |
|---|
| | | String strHex; |
|---|
| | | for (int i = 0; i < strText.length(); i++) { |
|---|
| | | c = strText.charAt(i); |
|---|
| | | intAsc = (int) c; |
|---|
| | | strHex = Integer.toHexString(intAsc); |
|---|
| | | if (intAsc > 128) |
|---|
| | | str.append("\\u" + strHex); |
|---|
| | | else |
|---|
| | | // 低位在前面补00 |
|---|
| | | str.append("\\u00" + strHex); |
|---|
| | | } |
|---|
| | | return str.toString(); |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * unicode的String转换成String的字符串 |
|---|
| | | * |
|---|
| | | * @param hex 16进制值字符串 （一个unicode为2byte） |
|---|
| | | * @return String 全角字符串 |
|---|
| | | */ |
|---|
| | | public static String unicodeToString(String hex) { |
|---|
| | | int t = hex.length() / 6; |
|---|
| | | StringBuilder str = new StringBuilder(); |
|---|
| | | for (int i = 0; i < t; i++) { |
|---|
| | | String s = hex.substring(i * 6, (i + 1) * 6); |
|---|
| | | // 高位需要补上00再转 |
|---|
| | | String s1 = s.substring(2, 4) + "00"; |
|---|
| | | // 低位直接转 |
|---|
| | | String s2 = s.substring(4); |
|---|
| | | // 将16进制的string转为int |
|---|
| | | int n = Integer.valueOf(s1, 16) + Integer.valueOf(s2, 16); |
|---|
| | | // 将int转换为字符 |
|---|
| | | char[] chars = Character.toChars(n); |
|---|
| | | str.append(new String(chars)); |
|---|
| | | } |
|---|
| | | return str.toString(); |
|---|
| | | } |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 将字节数组转换为十六进制字符数组 |
|---|
| | | * |
|---|
| | | * @param data byte[] |
|---|
| | | * @return 十六进制char[] |
|---|
| | | */ |
|---|
| | | public static char[] encodeHex(byte[] data) { |
|---|
| | | return encodeHex(data, true); |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 将字节数组转换为十六进制字符数组 |
|---|
| | | * |
|---|
| | | * @param data byte[] |
|---|
| | | * @param toLowerCase <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式 |
|---|
| | | * @return 十六进制char[] |
|---|
| | | */ |
|---|
| | | public static char[] encodeHex(byte[] data, boolean toLowerCase) { |
|---|
| | | return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER); |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 将字节数组转换为十六进制字符数组 |
|---|
| | | * |
|---|
| | | * @param data byte[] |
|---|
| | | * @param toDigits 用于控制输出的char[] |
|---|
| | | * @return 十六进制char[] |
|---|
| | | */ |
|---|
| | | protected static char[] encodeHex(byte[] data, char[] toDigits) { |
|---|
| | | int l = data.length; |
|---|
| | | char[] out = new char[l << 1]; |
|---|
| | | // two characters form the hex value. |
|---|
| | | for (int i = 0, j = 0; i < l; i++) { |
|---|
| | | out[j++] = toDigits[(0xF0 & data[i]) >>> 4]; |
|---|
| | | out[j++] = toDigits[0x0F & data[i]]; |
|---|
| | | } |
|---|
| | | return out; |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 将字节数组转换为十六进制字符串 |
|---|
| | | * |
|---|
| | | * @param data byte[] |
|---|
| | | * @return 十六进制String |
|---|
| | | */ |
|---|
| | | public static String encodeHexStr(byte[] data) { |
|---|
| | | return encodeHexStr(data, true); |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 将字节数组转换为十六进制字符串 |
|---|
| | | * |
|---|
| | | * @param data byte[] |
|---|
| | | * @param toLowerCase <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式 |
|---|
| | | * @return 十六进制String |
|---|
| | | */ |
|---|
| | | public static String encodeHexStr(byte[] data, boolean toLowerCase) { |
|---|
| | | return encodeHexStr(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER); |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 将字节数组转换为十六进制字符串 |
|---|
| | | * |
|---|
| | | * @param data byte[] |
|---|
| | | * @param toDigits 用于控制输出的char[] |
|---|
| | | * @return 十六进制String |
|---|
| | | */ |
|---|
| | | protected static String encodeHexStr(byte[] data, char[] toDigits) { |
|---|
| | | return new String(encodeHex(data, toDigits)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 将十六进制字符数组转换为字节数组 |
|---|
| | | * |
|---|
| | | * @param data 十六进制char[] |
|---|
| | | * @return byte[] |
|---|
| | | * @throws RuntimeException 如果源十六进制字符数组是一个奇怪的长度，将抛出运行时异常 |
|---|
| | | */ |
|---|
| | | public static byte[] decodeHex(char[] data) { |
|---|
| | | |
|---|
| | | int len = data.length; |
|---|
| | | |
|---|
| | | if ((len & 0x01) != 0) { |
|---|
| | | throw new RuntimeException("Odd number of characters."); |
|---|
| | | } |
|---|
| | | |
|---|
| | | byte[] out = new byte[len >> 1]; |
|---|
| | | |
|---|
| | | // two characters form the hex value. |
|---|
| | | for (int i = 0, j = 0; j < len; i++) { |
|---|
| | | int f = toDigit(data[j], j) << 4; |
|---|
| | | j++; |
|---|
| | | f = f | toDigit(data[j], j); |
|---|
| | | j++; |
|---|
| | | out[i] = (byte) (f & 0xFF); |
|---|
| | | } |
|---|
| | | |
|---|
| | | return out; |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 将十六进制字符转换成一个整数 |
|---|
| | | * |
|---|
| | | * @param ch 十六进制char |
|---|
| | | * @param index 十六进制字符在字符数组中的位置 |
|---|
| | | * @return 一个整数 |
|---|
| | | * @throws RuntimeException 当ch不是一个合法的十六进制字符时，抛出运行时异常 |
|---|
| | | */ |
|---|
| | | protected static int toDigit(char ch, int index) { |
|---|
| | | int digit = Character.digit(ch, 16); |
|---|
| | | if (digit == -1) { |
|---|
| | | throw new RuntimeException("Illegal hexadecimal character " + ch |
|---|
| | | + " at index " + index); |
|---|
| | | } |
|---|
| | | return digit; |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * float -> byte[] |
|---|
| | | * |
|---|
| | | * @param data |
|---|
| | | * @return |
|---|
| | | */ |
|---|
| | | public static byte[] getBytes(float data) { |
|---|
| | | int intBits = Float.floatToIntBits(data); |
|---|
| | | return intToByteArray(intBits); |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * double -> byte[] |
|---|
| | | * |
|---|
| | | * @param data |
|---|
| | | * @return |
|---|
| | | */ |
|---|
| | | public static byte[] getBytes(double data) { |
|---|
| | | long longBits = Double.doubleToLongBits(data); |
|---|
| | | return longToBytes(longBits); |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * byte[] -> float |
|---|
| | | * |
|---|
| | | * @param bytes |
|---|
| | | * @return |
|---|
| | | */ |
|---|
| | | public static float getFloat(byte[] bytes) { |
|---|
| | | return Float.intBitsToFloat(getInt(bytes)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | public static int getInt(byte[] bytes) { |
|---|
| | | return (0xff & bytes[0]) | (0xff00 & (bytes[1] << 8)) | (0xff0000 & (bytes[2] << 16)) | (0xff000000 & (bytes[3] << 24)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * byte[] -> double |
|---|
| | | * |
|---|
| | | * @return |
|---|
| | | */ |
|---|
| | | public static double getDouble(byte[] b) { |
|---|
| | | long l; |
|---|
| | | l = b[0]; |
|---|
| | | l &= 0xff; |
|---|
| | | l |= ((long) b[1] << 8); |
|---|
| | | l &= 0xffff; |
|---|
| | | l |= ((long) b[2] << 16); |
|---|
| | | l &= 0xffffff; |
|---|
| | | l |= ((long) b[3] << 24); |
|---|
| | | l &= 0xffffffffL; |
|---|
| | | l |= ((long) b[4] << 32); |
|---|
| | | l &= 0xffffffffffL; |
|---|
| | | l |= ((long) b[5] << 40); |
|---|
| | | l &= 0xffffffffffffL; |
|---|
| | | l |= ((long) b[6] << 48); |
|---|
| | | l &= 0xffffffffffffffL; |
|---|
| | | l |= ((long) b[7] << 56); |
|---|
| | | return Double.longBitsToDouble(l); |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 字节数组字符串 -> double |
|---|
| | | * |
|---|
| | | * @param bytesStr |
|---|
| | | * @return |
|---|
| | | */ |
|---|
| | | public static double getDouble(String bytesStr) { |
|---|
| | | byte[] aa = hexToBytes(bytesStr.toLowerCase()); |
|---|
| | | return getDouble(aa); |
|---|
| | | } |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 字节数组字符串 -> float |
|---|
| | | * |
|---|
| | | * @param bytesStr |
|---|
| | | * @return |
|---|
| | | */ |
|---|
| | | public static float getFloat(String bytesStr) { |
|---|
| | | byte[] aa = hexToBytes(bytesStr.toLowerCase()); |
|---|
| | | |
|---|
| | | return getFloat(aa); |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 16进制字符串 -> byte数组 |
|---|
| | | */ |
|---|
| | | public static byte[] str16ToByte(String str16) { |
|---|
| | | |
|---|
| | | int len = str16.length(); |
|---|
| | | if (len % 2 > 0) { |
|---|
| | | return null; |
|---|
| | | } |
|---|
| | | |
|---|
| | | byte res[] = new byte[len / 2]; |
|---|
| | | |
|---|
| | | for (int i = 0; i < len / 2; i++) { |
|---|
| | | String tmp = str16.substring(i*2, (i + 1) * 2); |
|---|
| | | byte t[] = hexToBytes(tmp); |
|---|
| | | res[i] = t[0]; |
|---|
| | | } |
|---|
| | | return res; |
|---|
| | | } |
|---|
| | | |
|---|
| | | |
|---|
| | | public static void main(String args[]) throws Exception { |
|---|
| | | String aa = "AAAACCCC220000000033373933343732393100000000000000000000000052D50451F77D5D406C04E275FD723C400000015F0000000507E70306103B0A"; |
|---|
| | | |
|---|
| | | String substring = aa.substring(20, 60); |
|---|
| | | String substring1 = aa.substring(60, 76); |
|---|
| | | String substring2 = aa.substring(76, 92); |
|---|
| | | // 编号 |
|---|
| | | String a1 = "AAAACCCC2200000000333739333437323931000000000000000000000000"; |
|---|
| | | |
|---|
| | | // 编号 |
|---|
| | | String a2 = "3739333437323931000000000000000000000000"; |
|---|
| | | System.out.println("a2 = " + hexStr2Str(a2)); |
|---|
| | | |
|---|
| | | //经 |
|---|
| | | String lng = "52D50451F77D5D40"; |
|---|
| | | System.out.println("lng = " + getDouble(lng)); |
|---|
| | | |
|---|
| | | String lat = "6C04E275FD723C40"; |
|---|
| | | System.out.println("lat = " + getDouble(lat)); |
|---|
| | | |
|---|
| | | //日 |
|---|
| | | String str = "0000"; |
|---|
| | | System.out.println("a = " + hexTohort(str)); |
|---|
| | | |
|---|
| | | |
|---|
| | | String str1 = "015F"; |
|---|
| | | System.out.println("b = " + hexTohort(str1)); |
|---|
| | | |
|---|
| | | //日 |
|---|
| | | String str2 = "0000"; |
|---|
| | | System.out.println("c = " + hexTohort(str2)); |
|---|
| | | |
|---|
| | | |
|---|
| | | String str3 = "0005"; |
|---|
| | | System.out.println("tr3 = " + hexTohort(str3)); |
|---|
| | | |
|---|
| | | |
|---|
| | | String nian = "07E7"; |
|---|
| | | System.out.println("nian = " + hexTohort(nian)); |
|---|
| | | |
|---|
| | | String yue = "03"; |
|---|
| | | System.out.println("yue = " + hexToByte(yue)); |
|---|
| | | |
|---|
| | | String ri = "06"; |
|---|
| | | System.out.println("ri = " + hexToByte(ri)); |
|---|
| | | |
|---|
| | | String h = "10"; |
|---|
| | | System.out.println("h = " + hexToByte(h)); |
|---|
| | | |
|---|
| | | String f = "3B"; |
|---|
| | | System.out.println("f = " + hexToByte(f)); |
|---|
| | | |
|---|
| | | String m = "0A"; |
|---|
| | | System.out.println("m = " + hexToByte(m)); |
|---|
| | | |
|---|
| | | } |
|---|
| | | |
|---|
| | | public static int toshort(String str) { |
|---|
| | | char[] in = str.toCharArray(); |
|---|
| | | /* |
|---|
| | | * for(int i=0;i<in.length;i+=2) { int value= tohx16(in[i]); int value2= |
|---|
| | | * tohx16(in[i+1]); int value3=value<<4|value2; |
|---|
| | | * |
|---|
| | | * System.out.print(value3); }//这里可设计照规则进行转换 |
|---|
| | | */ |
|---|
| | | int j = 0; |
|---|
| | | |
|---|
| | | for(int i=0;i<in.length;i+=2) { |
|---|
| | | int value= tohx16(in[i]); |
|---|
| | | int value2=tohx16(in[i+1]); |
|---|
| | | j=value<<4|value2; |
|---|
| | | } |
|---|
| | | return j; |
|---|
| | | } |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | public static int tohx16(char str) { |
|---|
| | | switch (str) { |
|---|
| | | case '0': |
|---|
| | | return 0; |
|---|
| | | case '1': |
|---|
| | | return '1'; |
|---|
| | | case '2': |
|---|
| | | return 2; |
|---|
| | | case '3': |
|---|
| | | return 3; |
|---|
| | | case '4': |
|---|
| | | return 4; |
|---|
| | | case '5': |
|---|
| | | return 5; |
|---|
| | | case '6': |
|---|
| | | return 6; |
|---|
| | | case '7': |
|---|
| | | return 7; |
|---|
| | | case '8': |
|---|
| | | return 8; |
|---|
| | | case '9': |
|---|
| | | return 9; |
|---|
| | | case 'a': |
|---|
| | | case 'A': |
|---|
| | | return 10; |
|---|
| | | case 'b': |
|---|
| | | case 'B': |
|---|
| | | return 11; |
|---|
| | | case 'c': |
|---|
| | | case 'C': |
|---|
| | | return 12; |
|---|
| | | case 'd': |
|---|
| | | case 'D': |
|---|
| | | return 13; |
|---|
| | | case 'e': |
|---|
| | | case 'E': |
|---|
| | | return 14; |
|---|
| | | case 'f': |
|---|
| | | case 'F': |
|---|
| | | return 15; |
|---|
| | | |
|---|
| | | } |
|---|
| | | |
|---|
| | | return 0; |
|---|
| | | } |
|---|
| | | |
|---|
| | | public static byte[] intToByteArray(int a) { |
|---|
| | | return new byte[]{ |
|---|
| | | (byte) ((a >> 24) & 0xFF), |
|---|
| | | (byte) ((a >> 16) & 0xFF), |
|---|
| | | (byte) ((a >> 8) & 0xFF), |
|---|
| | | (byte) (a & 0xFF) |
|---|
| | | }; |
|---|
| | | } |
|---|
| | | |
|---|
| | | public static byte intToByte(int a) { |
|---|
| | | return (byte) (a & 0xFF); |
|---|
| | | } |
|---|
| | | |
|---|
| | | public static byte[] longToBytes(long x) { |
|---|
| | | buffer.putLong(0, x); |
|---|
| | | return buffer.array(); |
|---|
| | | } |
|---|
| | | |
|---|
| | | |
|---|
| | | } |
|---|
| | | |
|---|
| | | |
|---|
