精华内容
下载资源
问答
  • 由C代码翻译过来的PHP CRC8算法,内有十六进制转字节数组与字节数组转十六进制,内有十六进制转byte数组与byte数组转十六进制
  • 怎么说,最近使用ssm框架的时候,需要将文件十六进制的字符串传入数据库,按照传统的sql,一个rs.getBinaryStream()还有rs.setBinaryStream()就可以了,可是在ssm里面就不能这么写的啦。要用纯java去遍历了。 ...

    怎么说,最近使用ssm框架的时候,需要将文件转成十六进制的字符串传入数据库,按照传统的sql,一个rs.getBinaryStream()还有rs.setBinaryStream()就可以了,可是在ssm里面就不能这么写的啦。要用纯java去遍历了。

     

    首先我们了解一下byte[]和十六进制字符串。

     

    众所周知,byte就是我们所说的字节,一个字节有8位的长度,而一个中文字占两个字节,一个十六进制的数用四位可以表示,有了这个基本的认知就可以开始进行转换了!

     

    16进制转byte数组

     

         String src = result.getBinaryFile();

            

          // 将十六进制转化为byte和String

          byte[] baKeyword = new byte[src.length()/2];

          for(int i = 0; i < baKeyword.length; i++) {

            try {

             // 当byte要转化为int的时候,高的24位必然会补1,这样,其二进制补码其实已经不一致了,&0xff可以将高的24位置为0,低8位保持原样。这样做的目的就是为了保证二进制数据的一致性。

             baKeyword[i] = (byte)(0xff & Integer.parseInt(src.substring(i*2, i*2+2),16));

            }

            catch(Exception e) {

             e.printStackTrace();

            }

            }

     

    关键在于明白一个十六进制占4位,需要两个十六进制才能构成一个字节,然后用Integer16进制输出,接下来还要用0xff对这数进行与(&)运算,原因是在于,这8位构成的数转成32位的INTEGER类型时,需要在前24位自动补1,这样很明显会造成偏差,所以就需要一个全1的十六进制数来和它进行与运算,将前24位转成0,后面的得以保留。这样baKeyword 出来的就是完整的byte数组了,就算里面有中文也可以资瓷啊!当然,可能你还需要把这个数组转成流输出到网页中,用来下载查看啥的,这样的话,只需要把inputStream = ByteArrayInputStream(baKeyword),然后用前台传过来的response.getoutputStream循环写一次就OK

     

    byte数组16进制

     

    ByteArrayOutputStream baos = new ByteArrayOutputStream();

                         byte[] b = new byte[4096];

                         int i = is.read(b);

                         while(i != -1) {

                         baos.write(b,0,i);

                         i = is.read(b);

                         }

    Byte[] a = baos.toByteArray()

     

    反过来明显简单一点,不过也是跟ByteArrayOutputStream脱不了关系。注意:这里的数组我用inputstream.read()代替了,你也可用数组循环遍历,都是一样的,用ByteArrayOutputStream循环写完后,byte数组就都在baos.toByteArray()里面了。

    展开全文
  • Java 十六进制String转byte数组

    千次阅读 2018-10-10 19:14:47
    Java 十六进制String转byte数组 标签(空格分隔): Java 文章目录Java 十六进制String转byte数组基本概念byte和byte[]转十六进制字符串十六进制字符串byte和byte[] 基本概念 十六进制(Hex): 0-9,a-f组成 二进制...

    Java 十六进制String转byte数组

    标签(空格分隔): Java


    基本概念

    十六进制(Hex): 0-9,a-f组成
    二进制: 01表示
    字节(byte): Java中一个字节表示8个二进制位
    字符(char): Java中一个字符有两个字节
    4个二进制位可以表示0-15,即0000-1111,所以可以表示一个十六进制数,一个字节就可以表示两个十六进制数。

    byte和byte[]转十六进制字符串

    /**
     * byte转Hex
     */
    public static String byteToHex(byte b) {
        String hex = Integer.toHexString(b & 0xFF);
        if(hex.length() < 2) {
            hex = "0" + hex;
        }
        return hex;
    }
    /**
     * byte[]转Hex
     */
    public static String bytesToHex(byte[] b) {
            StringBuffer sb = new StringBuffer();
            for(int i = 0; i < b.length; i++) {
                String hex = Integer.toHexString(b[i] & 0xFF);
                if(hex.length() < 2) {
                    hex = "0" + hex;
                }
                sb.append(hex.toUpperCase());
            }
    
            return sb.toString();
        }
    

    十六进制字符串转byte和byte[]

    /**
     * Hex转byte,hex只能含两个字符,如果是一个字符byte高位会是0
     */
    public static byte hexTobyte(String hex) {
            return (byte)Integer.parseInt(hex, 16);
        }
    /**
     * Hex转byte[],两种情况,Hex长度为奇数最后一个字符会被舍去
     */
    public static byte[] hexTobytes(String hex) {
            if (hex.length() < 1) {
                return null;
            } else {
                byte[] result = new byte[hex.length() / 2];
                int j = 0;
                for(int i = 0; i < hex.length(); i+=2) {
                    result[j++] = (byte)Integer.parseInt(hex.substring(i,i+2), 16);
                }
                return result;
            }
        }
    
    展开全文
  • 十进制字符串转十六进制byte数组转十六进制,亲测有效,如果对大家有点帮助,请大家多支持下博主。 后面为大家更新更多的实用技巧 下面展示代码。 import java.util.Locale; public class Fromain { public ...

    十进制字符串转十六进制,byte数组转十六进制,亲测有效,如果对大家有点帮助,请大家多支持下博主。

    后面为大家更新更多的实用技巧

    下面展示代码。

    import java.util.Locale;
    public class Fromain {
        public static void main(String[] args) {
            String s2 = "10";
            System.out.println(byteToHex(s2));
    
            byte [] str ={1,12};
            System.out.printf(bytes2HexString(str));
    
        }
    
        /**
         * 十进制字符串直接转十六进制字符串
         * @param str  字符串
         * @return   转换后的字符串
         */
        public static String byteToHex(String str) {
    
            Integer i = Integer.parseInt(str);
            String sd = Integer.toHexString(i);
    
            if (sd.length() == 1) {
                sd = "000" + sd;
            } else if (sd.length() == 2) {
                sd = "00" + sd;
            } else if (sd.length() == 3) {
                sd = "0" + sd;
            }
            return sd.toUpperCase(Locale.getDefault());
        }
    
        /**
         * byte 数组直接转十六进值字符串
         * @param b  数组
         * @return   字符串
         */
        public static String bytes2HexString(byte[] b) {
            StringBuilder r = new StringBuilder();
    
            for (byte value : b) {
                String hex = Integer.toHexString(value & 0xFF);
                if (hex.length() == 1) {
                    hex = '0' + hex;
                }
                r.append(hex.toUpperCase());
            }
    
            return r.toString();
        }
    }
    
    
    运算结果
    000A
    010C
    Process finished with exit code 0
    
    

    博主原文,转载请标明出处

    展开全文
  • 在c#项目中用到的二进制、十六进制与字节数组的相互转换 class HexCommon { /// <summary> /// 16进制字符串字节数组 /// 如01 02 ff 0a /// </summary> /// <param name="hexString".....

    在c#项目中用到的二进制、十六进制与字节数组的相互转换

     class HexCommon
        {
    
            /// <summary> 
            /// 16进制字符串转字节数组 
            /// 如01 02 ff 0a
            /// </summary> 
            /// <param name="hexString"></param> 
            /// <returns></returns> 
            public static byte[] strHexToByte(string hexString)
            {
                hexString = hexString.Replace(" ", "");
                if ((hexString.Length % 2) != 0)
                    hexString += " ";
                byte[] returnBytes = new byte[hexString.Length / 2];
                for (int i = 0; i < returnBytes.Length; i++)
                {
                    string temp = hexString.Substring(i * 2, 2).Trim();
                    returnBytes[i] = Convert.ToByte(temp, 16);
                }
                return returnBytes;
            }
    
    
            /// <summary>
            /// 6进制字符串转字节数组 
            /// </summary>
            /// <param name="hexString"></param>
            /// <param name="separator">分隔符</param>
            /// <returns></returns>
            public static byte[] strHexToByte(string hexString, char separator)
            {
                if (separator == char.MinValue)
                {
                    return strHexToByte(hexString);
                }
                string[] hexarray = hexString.Split(separator);
                List<string> temphexarray = new List<string>(hexarray);
                var newhexarray = temphexarray.Where(u => u != string.Empty);
    
                int len = newhexarray.Count();
                byte[] returnBytes = new byte[len];
    
                int i = 0;
                foreach (string str in newhexarray)
                {
    
                    string temp = str.Trim();
                    returnBytes[i] = Convert.ToByte(temp, 16);
                    i = i + 1;
                }
    
                return returnBytes;
    
            }
    
    
            /// <summary> 
            /// 字节数组转16进制字符串 
            /// </summary> 
            /// <param name="bytes"></param> 
            /// <returns></returns> 
            public static string byteToHexStr(byte[] bytes)
            {
                string returnStr = "";
                if (bytes != null)
                {
                    for (int i = 0; i < bytes.Length; i++)
                    {
                        returnStr += bytes[i].ToString("x2") + " ";
                    }
                }
                return returnStr.Trim();
            }
            /// <summary> 
            /// 字节数组转16进制字符串 (高低位反)
            /// </summary> 
            /// <param name="bytes"></param> 
            /// <returns></returns> 
            public static string byteToHexStrHL(byte[] bytes)
            {
                string returnStr = "";
                try
                {
                    if (bytes != null)
                    {
                        for (int i = 1; i < bytes.Length;)
                        {
                            returnStr += bytes[i].ToString("x2") + " ";
                            returnStr += bytes[i - 1].ToString("x2") + " ";
                            i = i + 2;
                        }
                    }
                }
                catch (Exception ex)
                {
                }
                return returnStr.Trim();
            }
    
            /// <summary> 
            /// 二进制字符串转字节数组 
            /// 如01001111 011111111 
            /// </summary> 
            /// <param name="hexString"></param> 
            /// <returns></returns> 
            public static byte[] strBinaryToByte(string binaryString)
            {
                binaryString = binaryString.Replace(" ", "");
                int yu = binaryString.Length % 8;
                //将字符串长度变成8的倍数
                if (yu != 0)
                    binaryString = binaryString.PadRight(binaryString.Length + 8 - yu);
                StringBuilder builder = new StringBuilder();
    
                byte[] returnBytes = new byte[binaryString.Length / 8];
                for (int i = 0; i < returnBytes.Length; i++)
                {
                    string temp = binaryString.Substring(i * 8, 8).Trim();
                    returnBytes[i] = Convert.ToByte(temp, 2);
                }
    
                return returnBytes;
            }
    
            /// <summary> 
            /// 二进制字符串转字节数组 
            /// 如01001111 011111111 
            /// </summary> 
            /// <param name="hexString"></param> 
            /// <param name="separator">分隔符</param>
            /// <returns></returns> 
            public static byte[] strBinaryToByte(string binaryString, char separator)
            {
                if (separator == char.MinValue)
                {
                    return strBinaryToByte(binaryString);
                }
                string[] binarray = binaryString.Split(separator);
                List<string> tempbinarray = new List<string>(binarray);
                var newbinarray = tempbinarray.Where(u => u != string.Empty);
    
                int len = newbinarray.Count();
                byte[] returnBytes = new byte[len];
                int i = 0;
                foreach (string str in newbinarray)
                {
    
                    string temp = str.Trim();
                    returnBytes[i] = Convert.ToByte(temp, 2);
                    i = i + 1;
                }
    
                return returnBytes;
            }
    
            /// <summary>
            /// 二进制字符串转16进制字符串(无分隔符)
            /// </summary>
            /// <param name="binaryString"></param>
            /// <returns></returns>
            public static string strBinaryTostrHex(string binaryString)
            {
                binaryString = binaryString.Replace(" ", "");
                int yu = binaryString.Length % 8;
                //将字符串长度变成8的倍数
                if (yu != 0)
                    binaryString = binaryString.PadRight(binaryString.Length + 8 - yu);
                StringBuilder builder = new StringBuilder();
                int len = binaryString.Length / 8;
                for (int i = 0; i < len; i++)
                {
                    string temp = binaryString.Substring(i * 8, 8).Trim();
                    string str = Convert.ToInt32(temp, 2).ToString("x2");
                    builder = builder.Append(str);
                }
                return builder.ToString();
            }
            /// <summary>
            /// 二进制字符串转16进制字符串(有分隔符)
            /// </summary>
            /// <param name="binaryString"></param>
            /// <param name="separator">分隔符</param>
            /// <returns></returns>
            public static string strBinaryTostrHex(string binaryString, char separator)
            {
                if (separator == char.MinValue)
                {
                    return strBinaryTostrHex(binaryString);
                }
                string[] binarray = binaryString.Split(separator);
    
                StringBuilder builder = new StringBuilder();
                int len = binarray.Length;
                for (int i = 0; i < len; i++)
                {
                    string bin = binarray[i].Trim();
                    if (bin == string.Empty) continue;
                    string str = Convert.ToInt32(bin, 2).ToString("x2");
                    builder = builder.Append(str);
                    builder = builder.Append(separator);
                }
                string returnvalue = builder.ToString();
                returnvalue = returnvalue.TrimEnd(separator);
                return returnvalue;
            }
    
    
            /// <summary>
            /// 16进制字符串 转换成2进制字符串,此方法用于没有分隔符
            /// 16进制格式"ff 01" 2进制格式 "10101001 11111111"
            /// </summary>
            /// <param name="hexString"></param>
            /// <returns></returns>
            public static string strHexTostrBinary(string hexString)
            {
    
                hexString = hexString.Replace(" ", "");
                if ((hexString.Length % 2) != 0)
                {
                    hexString = hexString.PadRight(hexString.Length + 1);
                }
    
                StringBuilder builder = new StringBuilder();
                int len = hexString.Length / 2;
                for (int i = 0; i < len; i++)
                {
                    string hex = hexString.Substring(i * 2, 2).Trim();
                    int a = Convert.ToInt32(hex, 16);
                    string str = Convert.ToString(a, 2).PadLeft(8, '0');
                    builder = builder.Append(str);
                }
                return builder.ToString();
            }
    
            /// <summary>
            /// 16进制字符串 转换成2进制字符串,此方法用于有分隔符 如空格
            /// 16进制格式"ff 01" 2进制格式 "10101001 11111111"
            /// </summary>
            /// <param name="hexString"></param>
            /// <returns></returns>
            public static string strHexTostrBinary(string hexString, char separator)
            {
                if (separator == char.MinValue)
                    return strHexTostrBinary(hexString);
    
                string[] hexarray = hexString.Split(separator);
    
                StringBuilder builder = new StringBuilder();
                int len = hexarray.Length;
                for (int i = 0; i < len; i++)
                {
                    string hex = hexarray[i].Trim();
                    if (hex == string.Empty) continue;
                    int a = Convert.ToInt32(hex, 16);
                    string str = Convert.ToString(a, 2).PadLeft(8, '0');
                    builder = builder.Append(str);
                    builder = builder.Append(separator.ToString());
                }
                string returnvalue = builder.ToString();
                returnvalue = returnvalue.TrimEnd(separator);
                return returnvalue;
            }
        }
    
    展开全文
  • 如何把一个十六进制byte数组转成十进制整数。 如 byte[2] = {0x01,0x00},即十六进制为0x0100,最终转为"256"? eg: byte[n] 转为十进制 for (int i = 0; i<n; i++) { result *= 256; result += byte[n-1-i]; }
  • byte数组转16进制 private static final char[] HEX_CHARS = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'}; /* * byte[]数组转十六进制 */ public static String bytes2hexStr(byte[]...
  • ///十进制字符串转换为十六进制///</summary>///<paramname="strCharSet"></param>///<returns></returns>publicstringTensStringToHexString(stringstrCharSet){...
  • 十六进制(Hex) 、 字节(Byte)、比特(bit) 十六进制(Hex):计算机中数据的一种表示方法,它由0-9,A-F组成,字母不区分大小写。与10进制的对应关系是:0-9对应0-9;A-F对应10-15。 官方语言以0x开始的数据表示...
  • Java 16进制byte数组

    千次阅读 2019-09-25 16:52:53
    一个十六进制数(Hex),正好为4个二进制位。一个字节(byte)为8个二进制位。因此,一个字节可表示为两个十六进制数字。我们可以将一个byte用两个Hex表示,同理,我们也可以将两个Hex转换为一个byte。 private ...
  • 读取txt文件中的16进制数组,默认...16进制byte需要将两个字符组成1个字节的byte类型; char * cArray = new char[]{'E' , 'F' , '2' ,'A'}; byte * by16 = new byte[cArray长度 / 2]; for (int i = 0, j=0; i &...
  • Java十六进制与字节数组的相互转换

    千次阅读 2018-06-13 22:04:23
    十六进制转换为字节数组 先获取到十六进制数字字符串的长度,如果是奇数,在前面补个零; 使用字符串的长度,计算出需要几个字节; 跟进字节个数创建字节数组; 将字符串转换为字符数组; 写一个循环,循环的次数...
  • 十六进制字符串转byte数组实现

    万次阅读 2017-12-26 13:55:12
    字符串转byte数组,就是实现如下功能:把一个字符串,比如“E4F1C3A81F”每两位作为一个十六进制数存到一个unsigned char 型的数组(buf)里,buf[0] = 0xE4,buf[1] = 0xF1,buf[2] = 0xC3,buf[3] = 0xA8.........
  • 十六进制与字节数组转换

    千次阅读 2018-05-30 11:17:03
    前段时间开发手持机上的软件,因为A8手持机的射频卡可存储的内容太小,并且需要存储16进制数据,因此就写了一个工具类。上代码:package cn.com.szh;import java.io.UnsupportedEncodingException;public class Main...
  • Java 十六进制字符与byte数组转换

    千次阅读 2013-02-01 11:02:38
    最近项目中需要把字节数组转换为十六进制数的形式,研究了好久终于实现了,分享一下 字节数组十六进制字符串之间的相互转换 /** * Convert byte[] to hex * string.这里我们可以将byte转换成int,然后...
  • 谢谢,联系:543644213
  • 将十进制byte数组转换成十六进制
  • Java Code public class Convert{ public static void main(String args[]) { String sHex = "00 B6 00 02 0A 28"; // 输入十六进制字符串 sHex = sHex.replace(" ", ""); // 去掉空格 ...
  • ///Convert a string of hex digits (ex: E4 CA B2) to a byte array.  ///The string containing the hex digits (with or without spaces).  ///Returns an array of bytes.  ...
  • c# 十六进制字串 Byte数组

    万次阅读 2010-10-27 11:28:00
    ///Convert a string of hex digits (ex: E4 CA B2) to a byte array. ///The string containing the hex digits (with or without spaces). ///Returns an array of bytes. private byte[] ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,739
精华内容 14,695
关键字:

十六进制转byte数组