[关闭]
@File 2020-04-10T03:41:00.000000Z 字数 4535 阅读 180

java-16进制

骚操作

  1. public class UseHex {
  3.     /**
  4.      * 用于建立十六进制字符的输出的小写字符数组
  5.      */
  6.     private static final char[] DIGITS_LOWER = {'0', '1', '2', '3', '4', '5',
  7.             '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
  9.     /**
  10.      * 用于建立十六进制字符的输出的大写字符数组
  11.      */
  12.     private static final char[] DIGITS_UPPER = {'0', '1', '2', '3', '4', '5',
  13.             '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
  16.     /**
  17.      * 字符串转换成十六进制字符串
  18.      *
  19.      * @param str       待转换的ASCII字符串
  20.      * @return          每个Byte之间空格分隔，如: [61 6C 6B]
  21.      */
  22.     public static String str2HexStr(String str) {
  24.         char[] chars = "0123456789ABCDEF".toCharArray();
  25.         StringBuilder sb = new StringBuilder("");
  26.         byte[] bs = str.getBytes();
  27.         int bit;
  29.         for (int i = 0; i < bs.length; i++) {
  30.             bit = (bs[i] & 0x0f0) >> 4;
  31.             sb.append(chars[bit]);
  32.             bit = bs[i] & 0x0f;
  33.             sb.append(chars[bit]);
  34.             sb.append(' ');
  35.         }
  36.         return sb.toString().trim();
  37.     }
  39.     /**
  40.      * 十六进制转换字符串
  41.      *
  42.      * @param hexStr        Byte字符串(Byte之间无分隔符 如:[616C6B])
  43.      * @return              对应的字符串
  44.      */
  45.     public static String hexStr2Str(String hexStr) {
  46.         String str = "0123456789ABCDEF";
  47.         char[] hexs = hexStr.toCharArray();
  48.         byte[] bytes = new byte[hexStr.length() / 2];
  49.         int n;
  51.         for (int i = 0; i < bytes.length; i++) {
  52.             n = str.indexOf(hexs[2 * i]) * 16;
  53.             n += str.indexOf(hexs[2 * i + 1]);
  54.             bytes[i] = (byte) (n & 0xff);
  55.         }
  56.         try {
  57.             return new String(bytes,"UTF-8");
  58.         } catch (UnsupportedEncodingException e) {
  59.             return "";
  60.         }
  61.     }
  63.     /**
  64.      * bytes转换成十六进制字符串
  65.      *
  66.      * @param b         byte数组
  67.      * @return          每个Byte值之间空格分隔
  68.      */
  69.     public static String byte2HexStr(byte[] b) {
  70.         String stmp = "";
  71.         StringBuilder sb = new StringBuilder("");
  72.         for (int n = 0; n < b.length; n++) {
  73.             stmp = Integer.toHexString(b[n] & 0xFF);
  74.             sb.append((stmp.length() == 1) ? "0" + stmp : stmp);
  75.         }
  76.         return sb.toString().toUpperCase().trim();
  77.     }
  79.     /**
  80.      * bytes字符串转换为Byte值
  81.      *
  82.      * @param src       Byte字符串，每个Byte之间没有分隔符
  83.      * @return
  84.      */
  85.     public static byte[] hexStr2Bytes(String src) {
  86.         int m = 0, n = 0;
  87.         int l = src.length() / 2;
  88.         System.out.println(l);
  89.         byte[] ret = new byte[l];
  90.         for (int i = 0; i < l; i++) {
  91.             m = i * 2 + 1;
  92.             n = m + 1;
  93.             ret[i] = Byte.decode("0x" + src.substring(i * 2, m) + src.substring(m, n));
  94.         }
  95.         return ret;
  96.     }
  98.     /**
  99.      * String的字符串转换成unicode的String
  100.      *
  101.      * @param strText       全角字符串
  102.      * @return              每个unicode之间无分隔符
  103.      * @throws Exception
  104.      */
  105.     public static String strToUnicode(String strText) throws Exception {
  106.         char c;
  107.         StringBuilder str = new StringBuilder();
  108.         int intAsc;
  109.         String strHex;
  110.         for (int i = 0; i < strText.length(); i++) {
  111.             c = strText.charAt(i);
  112.             intAsc = (int) c;
  113.             strHex = Integer.toHexString(intAsc);
  114.             str.append(intAsc > 128?"\\u":"\\u00");
  115.             str.append(strHex);
  116.         }
  117.         return str.toString();
  118.     }
  120.     /**
  121.      * unicode的String转换成String的字符串
  122.      *
  123.      * @param hex       16进制值字符串 （一个unicode为2byte）
  124.      * @return          全角字符串
  125.      */
  126.     public static String unicodeToString(String hex) {
  127.         int t = hex.length() / 6;
  128.         StringBuilder str = new StringBuilder();
  129.         for (int i = 0; i < t; i++) {
  130.             String s = hex.substring(i * 6, (i + 1) * 6);
  131.             // 高位需要补上00再转
  132.             String s1 = s.substring(2, 4) + "00";
  133.             // 低位直接转
  134.             String s2 = s.substring(4);
  135.             // 将16进制的string转为int
  136.             int n = Integer.valueOf(s1, 16) + Integer.valueOf(s2, 16);
  137.             // 将int转换为字符
  138.             char[] chars = Character.toChars(n);
  139.             str.append(new String(chars));
  140.         }
  141.         return str.toString();
  142.     }
  145.     /**
  146.      * 将字节数组转换为十六进制字符数组
  147.      *
  148.      * @param data byte[]
  149.      * @return 十六进制char[]
  150.      */
  151.     public static char[] encodeHex(byte[] data) {
  152.         return encodeHex(data, true);
  153.     }
  155.     /**
  156.      * 将字节数组转换为十六进制字符数组
  157.      *
  158.      * @param data        byte[]
  159.      * @param toLowerCase <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式
  160.      * @return 十六进制char[]
  161.      */
  162.     public static char[] encodeHex(byte[] data, boolean toLowerCase) {
  163.         return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
  164.     }
  166.     /**
  167.      * 将字节数组转换为十六进制字符数组
  168.      *
  169.      * @param data     byte[]
  170.      * @param toDigits 用于控制输出的char[]
  171.      * @return 十六进制char[]
  172.      */
  173.     protected static char[] encodeHex(byte[] data, char[] toDigits) {
  174.         int l = data.length;
  175.         char[] out = new char[l << 1];
  176.         // two characters form the hex value.
  177.         for (int i = 0, j = 0; i < l; i++) {
  178.             out[j++] = toDigits[(0xF0 & data[i]) >>> 4];
  179.             out[j++] = toDigits[0x0F & data[i]];
  180.         }
  181.         return out;
  182.     }
  184.     /**
  185.      * 将字节数组转换为十六进制字符串
  186.      *
  187.      * @param data byte[]
  188.      * @return 十六进制String
  189.      */
  190.     public static String encodeHexStr(byte[] data) {
  191.         return encodeHexStr(data, true);
  192.     }
  194.     /**
  195.      * 将字节数组转换为十六进制字符串
  196.      *
  197.      * @param data        byte[]
  198.      * @param toLowerCase <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式
  199.      * @return 十六进制String
  200.      */
  201.     public static String encodeHexStr(byte[] data, boolean toLowerCase) {
  202.         return encodeHexStr(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
  203.     }
  205.     /**
  206.      * 将字节数组转换为十六进制字符串
  207.      *
  208.      * @param data     byte[]
  209.      * @param toDigits 用于控制输出的char[]
  210.      * @return 十六进制String
  211.      */
  212.     protected static String encodeHexStr(byte[] data, char[] toDigits) {
  213.         return new String(encodeHex(data, toDigits));
  214.     }
  216.     /**
  217.      * 将十六进制字符数组转换为字节数组
  218.      *
  219.      * @param data 十六进制char[]
  220.      * @return byte[]
  221.      * @throws RuntimeException 如果源十六进制字符数组是一个奇怪的长度，将抛出运行时异常
  222.      */
  223.     public static byte[] decodeHex(char[] data) {
  225.         int len = data.length;
  227.         if ((len & 0x01) != 0) {
  228.             throw new RuntimeException("Odd number of characters.");
  229.         }
  231.         byte[] out = new byte[len >> 1];
  233.         // two characters form the hex value.
  234.         for (int i = 0, j = 0; j < len; i++) {
  235.             int f = toDigit(data[j], j) << 4;
  236.             j++;
  237.             f = f | toDigit(data[j], j);
  238.             j++;
  239.             out[i] = (byte) (f & 0xFF);
  240.         }
  242.         return out;
  243.     }
  245.     /**
  246.      * 将十六进制字符转换成一个整数
  247.      *
  248.      * @param ch    十六进制char
  249.      * @param index 十六进制字符在字符数组中的位置
  250.      * @return      一个整数
  251.      * @throws RuntimeException 当ch不是一个合法的十六进制字符时，抛出运行时异常
  252.      */
  253.     protected static int toDigit(char ch, int index) {
  254.         int digit = Character.digit(ch, 16);
  255.         if (digit == -1) {
  256.             throw new RuntimeException("Illegal hexadecimal character " + ch
  257.                     + " at index " + index);
  258.         }
  259.         return digit;
  260.     }
  261. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注