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