字节、字符串、hex字符串 相互转换工具类

旧城等待， 2023-10-05 21:21 115阅读 0赞 
  1. package com.lys.sec.common;
  3. import java.math.BigInteger;
  5. public class ByteHexUtil {
  6.     /**
  7.      * 整形转换成网络传输的字节流（字节数组）型数据
  8.      *
  9.      * @param num
  10.      *            一个整型数据
  11.      * @return 4个字节的自己数组
  12.      */
  13.     public static byte[] intToBytes(int num) {
  14.         byte[] bytes = new byte[4];
  15.         bytes[0] = (byte) (0xff & (num >> 0));
  16.         bytes[1] = (byte) (0xff & (num >> 8));
  17.         bytes[2] = (byte) (0xff & (num >> 16));
  18.         bytes[3] = (byte) (0xff & (num >> 24));
  19.         return bytes;
  20.     }
  22.     /**
  23.      * 四个字节的字节数据转换成一个整形数据
  24.      *
  25.      * @param bytes
  26.      *            4个字节的字节数组
  27.      * @return 一个整型数据
  28.      */
  29.     public static int byteToInt(byte[] bytes) {
  30.         int num = 0;
  31.         int temp;
  32.         temp = (0x000000ff & (bytes[0])) << 0;
  33.         num = num | temp;
  34.         temp = (0x000000ff & (bytes[1])) << 8;
  35.         num = num | temp;
  36.         temp = (0x000000ff & (bytes[2])) << 16;
  37.         num = num | temp;
  38.         temp = (0x000000ff & (bytes[3])) << 24;
  39.         num = num | temp;
  40.         return num;
  41.     }
  43.     /**
  44.      * 长整形转换成网络传输的字节流（字节数组）型数据
  45.      *
  46.      * @param num
  47.      *            一个长整型数据
  48.      * @return 4个字节的自己数组
  49.      */
  50.     public static byte[] longToBytes(long num) {
  51.         byte[] bytes = new byte[8];
  52.         for (int i = 0; i < 8; i++) {
  53.             bytes[i] = (byte) (0xff & (num >> (i * 8)));
  54.         }
  56.         return bytes;
  57.     }
  59.     /**
  60.      * 大数字转换字节流（字节数组）型数据
  61.      *
  62.      * @param n
  63.      * @return
  64.      */
  65.     public static byte[] byteConvert32Bytes(BigInteger n) {
  66.         byte tmpd[] = (byte[]) null;
  67.         if (n == null) {
  68.             return null;
  69.         }
  71.         if (n.toByteArray().length == 33) {
  72.             tmpd = new byte[32];
  73.             System.arraycopy(n.toByteArray(), 1, tmpd, 0, 32);
  74.         } else if (n.toByteArray().length == 32) {
  75.             tmpd = n.toByteArray();
  76.         } else {
  77.             tmpd = new byte[32];
  78.             for (int i = 0; i < 32 - n.toByteArray().length; i++) {
  79.                 tmpd[i] = 0;
  80.             }
  81.             System.arraycopy(n.toByteArray(), 0, tmpd, 32 - n.toByteArray().length, n.toByteArray().length);
  82.         }
  83.         return tmpd;
  84.     }
  86.     /**
  87.      * 换字节流（字节数组）型数据转大数字
  88.      *
  89.      * @param b
  90.      * @return
  91.      */
  92.     public static BigInteger byteConvertInteger(byte[] b) {
  93.         if (b[0] < 0) {
  94.             byte[] temp = new byte[b.length + 1];
  95.             temp[0] = 0;
  96.             System.arraycopy(b, 0, temp, 1, b.length);
  97.             return new BigInteger(temp);
  98.         }
  99.         return new BigInteger(b);
  100.     }
  102.     /**
  103.      * 根据字节数组获得值(十六进制数字)
  104.      *
  105.      * @param bytes
  106.      * @return
  107.      */
  108.     public static String getHexString(byte[] bytes) {
  109.         return getHexString(bytes, true);
  110.     }
  112.     /**
  113.      * 根据字节数组获得值(十六进制数字)
  114.      *
  115.      * @param bytes
  116.      * @param upperCase
  117.      * @return
  118.      */
  119.     public static String getHexString(byte[] bytes, boolean upperCase) {
  120.         String ret = "";
  121.         for (int i = 0; i < bytes.length; i++) {
  122.             ret += Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1);
  123.         }
  124.         return upperCase ? ret.toUpperCase() : ret;
  125.     }
  127.     /**
  128.      * 打印十六进制字符串
  129.      *
  130.      * @param bytes
  131.      */
  132.     public static void printHexString(byte[] bytes) {
  133.         for (int i = 0; i < bytes.length; i++) {
  134.             String hex = Integer.toHexString(bytes[i] & 0xFF);
  135.             if (hex.length() == 1) {
  136.                 hex = '0' + hex;
  137.             }
  138.             System.out.print("0x" + hex.toUpperCase() + ",");
  139.         }
  140.         System.out.println("");
  141.     }
  143.     /**
  144.      * Convert hex string to byte[]
  145.      *
  146.      * @param hexString
  147.      *            the hex string
  148.      * @return byte[]
  149.      */
  150.     public static byte[] hexStringToBytes(String hexString) {
  151.         if (hexString == null || hexString.equals("")) {
  152.             return null;
  153.         }
  155.         hexString = hexString.toUpperCase();
  156.         int length = hexString.length() / 2;
  157.         char[] hexChars = hexString.toCharArray();
  158.         byte[] d = new byte[length];
  159.         for (int i = 0; i < length; i++) {
  160.             int pos = i * 2;
  161.             d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
  162.         }
  163.         return d;
  164.     }
  166.     /**
  167.      * Convert char to byte
  168.      *
  169.      * @param c
  170.      *            char
  171.      * @return byte
  172.      */
  173.     public static byte charToByte(char c) {
  174.         return (byte) "0123456789ABCDEF".indexOf(c);
  175.     }
  177.     /**
  178.      * 用于建立十六进制字符的输出的小写字符数组
  179.      */
  180.     private static final char[] DIGITS_LOWER = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd',
  181.             'e', 'f' };
  183.     /**
  184.      * 用于建立十六进制字符的输出的大写字符数组
  185.      */
  186.     private static final char[] DIGITS_UPPER = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
  187.             'E', 'F' };
  189.     /**
  190.      * 将字节数组转换为十六进制字符数组
  191.      *
  192.      * @param data
  193.      *            byte[]
  194.      * @return 十六进制char[]
  195.      */
  196.     public static char[] encodeHex(byte[] data) {
  197.         return encodeHex(data, true);
  198.     }
  200.     /**
  201.      * 将字节数组转换为十六进制字符数组
  202.      *
  203.      * @param data
  204.      *            byte[]
  205.      * @param toLowerCase
  206.      *            <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式
  207.      * @return 十六进制char[]
  208.      */
  209.     public static char[] encodeHex(byte[] data, boolean toLowerCase) {
  210.         return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
  211.     }
  213.     /**
  214.      * 将字节数组转换为十六进制字符数组
  215.      *
  216.      * @param data
  217.      *            byte[]
  218.      * @param toDigits
  219.      *            用于控制输出的char[]
  220.      * @return 十六进制char[]
  221.      */
  222.     protected static char[] encodeHex(byte[] data, char[] toDigits) {
  223.         int l = data.length;
  224.         char[] out = new char[l << 1];
  225.         // two characters form the hex value.
  226.         for (int i = 0, j = 0; i < l; i++) {
  227.             out[j++] = toDigits[(0xF0 & data[i]) >>> 4];
  228.             out[j++] = toDigits[0x0F & data[i]];
  229.         }
  230.         return out;
  231.     }
  233.     /**
  234.      * 将字节数组转换为十六进制字符串
  235.      *
  236.      * @param data
  237.      *            byte[]
  238.      * @return 十六进制String
  239.      */
  240.     public static String encodeHexString(byte[] data) {
  241.         return encodeHexString(data, true);
  242.     }
  244.     /**
  245.      * 将字节数组转换为十六进制字符串
  246.      *
  247.      * @param data
  248.      *            byte[]
  249.      * @param toLowerCase
  250.      *            <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式
  251.      * @return 十六进制String
  252.      */
  253.     public static String encodeHexString(byte[] data, boolean toLowerCase) {
  254.         return encodeHexString(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
  255.     }
  257.     /**
  258.      * 将字节数组转换为十六进制字符串
  259.      *
  260.      * @param data
  261.      *            byte[]
  262.      * @param toDigits
  263.      *            用于控制输出的char[]
  264.      * @return 十六进制String
  265.      */
  266.     protected static String encodeHexString(byte[] data, char[] toDigits) {
  267.         return new String(encodeHex(data, toDigits));
  268.     }
  270.     /**
  271.      * 将十六进制字符数组转换为字节数组
  272.      *
  273.      * @param data
  274.      *            十六进制char[]
  275.      * @return byte[]
  276.      * @throws RuntimeException
  277.      *             如果源十六进制字符数组是一个奇怪的长度，将抛出运行时异常
  278.      */
  279.     public static byte[] decodeHex(char[] data) {
  280.         int len = data.length;
  282.         if ((len & 0x01) != 0) {
  283.             throw new RuntimeException("Odd number of characters.");
  284.         }
  286.         byte[] out = new byte[len >> 1];
  288.         // two characters form the hex value.
  289.         for (int i = 0, j = 0; j < len; i++) {
  290.             int f = toDigit(data[j], j) << 4;
  291.             j++;
  292.             f = f | toDigit(data[j], j);
  293.             j++;
  294.             out[i] = (byte) (f & 0xFF);
  295.         }
  297.         return out;
  298.     }
  300.     /**
  301.      * 将十六进制字符转换成一个整数
  302.      *
  303.      * @param ch
  304.      *            十六进制char
  305.      * @param index
  306.      *            十六进制字符在字符数组中的位置
  307.      * @return 一个整数
  308.      * @throws RuntimeException
  309.      *             当ch不是一个合法的十六进制字符时，抛出运行时异常
  310.      */
  311.     protected static int toDigit(char ch, int index) {
  312.         int digit = Character.digit(ch, 16);
  313.         if (digit == -1) {
  314.             throw new RuntimeException("Illegal hexadecimal character " + ch + " at index " + index);
  315.         }
  316.         return digit;
  317.     }
  319.     /**
  320.      * 数字字符串转ASCII码字符串
  321.      *
  322.      * @param String
  323.      *            字符串
  324.      * @return ASCII字符串
  325.      */
  326.     public static String StringToAsciiString(String content) {
  327.         String result = "";
  328.         int max = content.length();
  329.         for (int i = 0; i < max; i++) {
  330.             char c = content.charAt(i);
  331.             String b = Integer.toHexString(c);
  332.             result = result + b;
  333.         }
  334.         return result;
  335.     }
  337.     /**
  338.      * 十六进制转字符串
  339.      *
  340.      * @param hexString
  341.      *            十六进制字符串
  342.      * @param encodeType
  343.      *            编码类型4：Unicode，2：普通编码
  344.      * @return 字符串
  345.      */
  346.     public static String hexStringToString(String hexString, int encodeType) {
  347.         String result = "";
  348.         int max = hexString.length() / encodeType;
  349.         for (int i = 0; i < max; i++) {
  350.             char c = (char) hexStringToAlgorism(hexString.substring(i * encodeType, (i + 1) * encodeType));
  351.             result += c;
  352.         }
  353.         return result;
  354.     }
  356.     /**
  357.      * 十六进制字符串装十进制
  358.      *
  359.      * @param hex
  360.      *            十六进制字符串
  361.      * @return 十进制数值
  362.      */
  363.     public static int hexStringToAlgorism(String hex) {
  364.         hex = hex.toUpperCase();
  365.         int max = hex.length();
  366.         int result = 0;
  367.         for (int i = max; i > 0; i--) {
  368.             char c = hex.charAt(i - 1);
  369.             int algorism = 0;
  370.             if (c >= '0' && c <= '9') {
  371.                 algorism = c - '0';
  372.             } else {
  373.                 algorism = c - 55;
  374.             }
  375.             result += Math.pow(16, max - i) * algorism;
  376.         }
  377.         return result;
  378.     }
  380.     /**
  381.      * 十六转二进制
  382.      *
  383.      * @param hex
  384.      *            十六进制字符串
  385.      * @return 二进制字符串
  386.      */
  387.     public static String hexStringToBinary(String hex) {
  388.         hex = hex.toUpperCase();
  389.         String result = "";
  390.         int max = hex.length();
  391.         for (int i = 0; i < max; i++) {
  392.             char c = hex.charAt(i);
  393.             switch (c) {
  394.             case '0':
  395.                 result += "0000";
  396.                 break;
  397.             case '1':
  398.                 result += "0001";
  399.                 break;
  400.             case '2':
  401.                 result += "0010";
  402.                 break;
  403.             case '3':
  404.                 result += "0011";
  405.                 break;
  406.             case '4':
  407.                 result += "0100";
  408.                 break;
  409.             case '5':
  410.                 result += "0101";
  411.                 break;
  412.             case '6':
  413.                 result += "0110";
  414.                 break;
  415.             case '7':
  416.                 result += "0111";
  417.                 break;
  418.             case '8':
  419.                 result += "1000";
  420.                 break;
  421.             case '9':
  422.                 result += "1001";
  423.                 break;
  424.             case 'A':
  425.                 result += "1010";
  426.                 break;
  427.             case 'B':
  428.                 result += "1011";
  429.                 break;
  430.             case 'C':
  431.                 result += "1100";
  432.                 break;
  433.             case 'D':
  434.                 result += "1101";
  435.                 break;
  436.             case 'E':
  437.                 result += "1110";
  438.                 break;
  439.             case 'F':
  440.                 result += "1111";
  441.                 break;
  442.             }
  443.         }
  444.         return result;
  445.     }
  447.     /**
  448.      * ASCII码字符串转数字字符串
  449.      *
  450.      * @param String
  451.      *            ASCII字符串
  452.      * @return 字符串
  453.      */
  454.     public static String AsciiStringToString(String content) {
  455.         String result = "";
  456.         int length = content.length() / 2;
  457.         for (int i = 0; i < length; i++) {
  458.             String c = content.substring(i * 2, i * 2 + 2);
  459.             int a = hexStringToAlgorism(c);
  460.             char b = (char) a;
  461.             String d = String.valueOf(b);
  462.             result += d;
  463.         }
  464.         return result;
  465.     }
  467.     /**
  468.      * 将十进制转换为指定长度的十六进制字符串
  469.      *
  470.      * @param algorism
  471.      *            int 十进制数字
  472.      * @param maxLength
  473.      *            int 转换后的十六进制字符串长度
  474.      * @return String 转换后的十六进制字符串
  475.      */
  476.     public static String algorismToHexString(int algorism, int maxLength) {
  477.         String result = "";
  478.         result = Integer.toHexString(algorism);
  480.         if (result.length() % 2 == 1) {
  481.             result = "0" + result;
  482.         }
  483.         return patchHexString(result.toUpperCase(), maxLength);
  484.     }
  486.     /**
  487.      * 字节数组转为普通字符串（ASCII对应的字符）
  488.      *
  489.      * @param bytearray
  490.      *            byte[]
  491.      * @return String
  492.      */
  493.     public static String byteToString(byte[] bytearray) {
  494.         String result = "";
  495.         char temp;
  497.         int length = bytearray.length;
  498.         for (int i = 0; i < length; i++) {
  499.             temp = (char) bytearray[i];
  500.             result += temp;
  501.         }
  502.         return result;
  503.     }
  505.     /**
  506.      * 二进制字符串转十进制
  507.      *
  508.      * @param binary
  509.      *            二进制字符串
  510.      * @return 十进制数值
  511.      */
  512.     public static int binaryToAlgorism(String binary) {
  513.         int max = binary.length();
  514.         int result = 0;
  515.         for (int i = max; i > 0; i--) {
  516.             char c = binary.charAt(i - 1);
  517.             int algorism = c - '0';
  518.             result += Math.pow(2, max - i) * algorism;
  519.         }
  520.         return result;
  521.     }
  523.     /**
  524.      * 十进制转换为十六进制字符串
  525.      *
  526.      * @param algorism
  527.      *            int 十进制的数字
  528.      * @return String 对应的十六进制字符串
  529.      */
  530.     public static String algorismToHEXString(int algorism) {
  531.         String result = "";
  532.         result = Integer.toHexString(algorism);
  534.         if (result.length() % 2 == 1) {
  535.             result = "0" + result;
  537.         }
  538.         result = result.toUpperCase();
  540.         return result;
  541.     }
  543.     /**
  544.      * HEX字符串前补0，主要用于长度位数不足。
  545.      *
  546.      * @param str
  547.      *            String 需要补充长度的十六进制字符串
  548.      * @param maxLength
  549.      *            int 补充后十六进制字符串的长度
  550.      * @return 补充结果
  551.      */
  552.     static public String patchHexString(String str, int maxLength) {
  553.         String temp = "";
  554.         for (int i = 0; i < maxLength - str.length(); i++) {
  555.             temp = "0" + temp;
  556.         }
  557.         str = (temp + str).substring(0, maxLength);
  558.         return str;
  559.     }
  561.     /**
  562.      * 将一个字符串转换为int
  563.      *
  564.      * @param s
  565.      *            String 要转换的字符串
  566.      * @param defaultInt
  567.      *            int 如果出现异常,默认返回的数字
  568.      * @param radix
  569.      *            int 要转换的字符串是什么进制的,如16 8 10.
  570.      * @return int 转换后的数字
  571.      */
  572.     public static int parseToInt(String s, int defaultInt, int radix) {
  573.         int i = 0;
  574.         try {
  575.             i = Integer.parseInt(s, radix);
  576.         } catch (NumberFormatException ex) {
  577.             i = defaultInt;
  578.         }
  579.         return i;
  580.     }
  582.     /**
  583.      * 将一个十进制形式的数字字符串转换为int
  584.      *
  585.      * @param s
  586.      *            String 要转换的字符串
  587.      * @param defaultInt
  588.      *            int 如果出现异常,默认返回的数字
  589.      * @return int 转换后的数字
  590.      */
  591.     public static int parseToInt(String s, int defaultInt) {
  592.         int i = 0;
  593.         try {
  594.             i = Integer.parseInt(s);
  595.         } catch (NumberFormatException ex) {
  596.             i = defaultInt;
  597.         }
  598.         return i;
  599.     }
  601.     /**
  602.      * 十六进制串转化为byte数组
  603.      *
  604.      * @return the array of byte
  605.      */
  606.     public static byte[] hexToByte(String hex) throws IllegalArgumentException {
  607.         if (hex.length() % 2 != 0) {
  608.             throw new IllegalArgumentException();
  609.         }
  610.         char[] arr = hex.toCharArray();
  611.         byte[] b = new byte[hex.length() / 2];
  612.         for (int i = 0, j = 0, l = hex.length(); i < l; i++, j++) {
  613.             String swap = "" + arr[i++] + arr[i];
  614.             int byteint = Integer.parseInt(swap, 16) & 0xFF;
  615.             b[j] = new Integer(byteint).byteValue();
  616.         }
  617.         return b;
  618.     }
  620.     /**
  621.      * 字节数组转换为十六进制字符串
  622.      *
  623.      * @param b
  624.      *            byte[] 需要转换的字节数组
  625.      * @return String 十六进制字符串
  626.      */
  627.     public static String byteToHex(byte b[]) {
  628.         if (b == null) {
  629.             throw new IllegalArgumentException("Argument b ( byte array ) is null! ");
  630.         }
  631.         String hs = "";
  632.         String stmp = "";
  633.         for (int n = 0; n < b.length; n++) {
  634.             stmp = Integer.toHexString(b[n] & 0xff);
  635.             if (stmp.length() == 1) {
  636.                 hs = hs + "0" + stmp;
  637.             } else {
  638.                 hs = hs + stmp;
  639.             }
  640.         }
  641.         return hs.toUpperCase();
  642.     }
  644.     public static byte[] subByte(byte[] input, int startIndex, int length) {
  645.         byte[] bt = new byte[length];
  646.         for (int i = 0; i < length; i++) {
  647.             bt[i] = input[i + startIndex];
  648.         }
  649.         return bt;
  650.     }
  652. }

发表评论

表情：
评论列表 （有 0 条评论，115人围观）

还没有评论，来说两句吧...

相关阅读