精华内容
下载资源
问答
  • byte数组、十进制、十六进制间的两两转换
  • 字符串 byte[]——含中文 /** * 字符串转byte数组 * @param str * @return */ public static byte[] strTobytes(String str){ byte[] b=null,data=null; try{ b = str.getBytes("utf-8"); //data = new ...

     bytez转String

    /**
     * 字节数组转换成对应的16进制表示的字符串
     *
     * @param src
     * @return
     */
    public static String bytes2HexStr(byte[] src) {
        StringBuilder builder = new StringBuilder();
        if (src == null || src.length <= 0) {
            return "";
        }
        char[] buffer = new char[2];
        for (int i = 0; i < src.length; i++) {
            buffer[0] = Character.forDigit((src[i] >>> 4) & 0x0F, 16);
            buffer[1] = Character.forDigit(src[i] & 0x0F, 16);
            builder.append(buffer);
        }
        return builder.toString().toUpperCase();
    }
    
    /**
     * 十六进制字节数组转字符串
     *
     * @param src    目标数组
     * @param dec    起始位置
     * @param length 长度
     * @return
     */
    public static String bytes2HexStr(byte[] src, int dec, int length) {
        byte[] temp = new byte[length];
        System.arraycopy(src, dec, temp, 0, length);
        return bytes2HexStr(temp);
    }
    BMSID = new String(bytes2, StandardCharsets.US_ASCII).trim();

    字符串转 byte[]——含中文

    /**
     * 字符串转byte数组
     * @param str
     * @return
     */
    public static byte[] strTobytes(String str){
        byte[] b=null,data=null;
        try{
            b = str.getBytes("utf-8");
            //data = new String(b,"utf-8").getBytes("gbk");
            data = new String(b,"utf-8").getBytes("gb2312");
        }catch (UnsupportedEncodingException e){
            e.printStackTrace();
        }
        return data;
    }

     

    字符串命令转 byte[]——不含中文

    /**
     * 把十六进制表示的字节数组字符串,转换成十六进制字节数组
     *
     * @param
     * @return byte[]
     */
    public static byte[] hexStr2bytes(String hex) {
        int len = (hex.length() / 2);
        byte[] result = new byte[len];
        char[] achar = hex.toUpperCase().toCharArray();
        for (int i = 0; i < len; i++) {
            int pos = i * 2;
            result[i] = (byte) (hexChar2byte(achar[pos]) << 4 | hexChar2byte(achar[pos + 1]));
        }
        return result;
    }

    String与byte转换

    String s = "这是一段中文字符串";
    byte[] b = new byte[0];
    try {
        b = s.getBytes("UTF-8");
        String n = new String(b,"UTF-8");
        LgqLogutil.e(".......==="+n);
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();

     byte[]转二进制0010100

    public static String convertToBinaryString(byte[] data) {
        LogPlus.e("###data len   -> " + data.length);
        StringBuilder sb = new StringBuilder();
        for (int i = 0, n = data.length; i < n; ++i) {
            String bin = Integer.toBinaryString(data[i] & 0xFF);
    
            StringBuilder binaryStr = new StringBuilder();
            final int zeroPaddingLen = 8 - bin.length();
            for (int j = 0; j < zeroPaddingLen; ++j) {
                binaryStr.append("0");
            }
            binaryStr.append(bin);
            sb.append(binaryStr);
        }
        return sb.toString();
    }

    二进制转十进制转byte[]

     

    byte[] dataN = new byte[4];
    int[] allLed = new int[32];
    int value = Integer.parseInt(convertToBinnaryStr(allLed), 2);
    
    byte[] lengthBytes = ByteUtil.int2Bytes(value, 4);
    private String convertToBinnaryStr(int[] allLed) {
        StringBuilder sb = new StringBuilder();
        for (int b : allLed) {
            sb.append(b);
        }
        return sb.toString();
    }
    public static byte[] int2Bytes(int v, int len) {
        byte[] bytes = new byte[len];
        for (int i = 0; i < len; i++) {
            // 高位在前
            bytes[i] = (byte) ((v >>> (len - i - 1) * 8) & 0xff);
        }
        return bytes;
    }

     

     byte[]转十进制

    public static int byteToInt(byte[] b) {
        int mask = 0xff;
        int temp;
        int n = 0;
        for (int i = 0; i < b.length; i++) {
            n <<= 8;
            temp = b[i] & mask;
            n |= temp;
        }
        return n;
    }

    byte[]拼接方法

     

    byte[] dataN = new byte[6];
    byte[] lengthBytes = ByteUtil.int2Bytes(liushui, 4);
    System.arraycopy(lengthBytes, 0, dataN, 0, lengthBytes.length);
    byte[] buyNumBytes = ByteUtil.int2Bytes(num, 1);
    byte[] huodaohaoBytes = ByteUtil.int2Bytes(goodsWayId, 1);
    System.arraycopy(huodaohaoBytes, 0, dataN, 4, 1);
    System.arraycopy(buyNumBytes, 0, dataN, 5, 1);
    setDataN(dataN);

     校验

    /**
     * 异或校验和
     *
     * @param bytes
     * @param offset
     * @param len
     * @return
     */
    public static byte getXOR(byte[] bytes, int offset, int len) {
        // 计算校验和 
        byte toDiff = 0;
        // 校验和为除开校验位外的所有数据做异或
        for (int i = 0; i < len; i++) {
            toDiff = (byte) (toDiff ^ bytes[i + offset]);
        }
        return toDiff;
    }
    // 计算校验和
    byte check = ByteUtil.getXOR(bytes, 0, bytes.length - 1);

     。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

    /**
     * 总加和校验
     * @param data 十六进制字符串
     * @return 返回校验码
     */
    public static String checksum(String data) {
        if (data == null || data.equals("")) {
            return "";
        }
        int total = 0;
        int len = data.length();
        int num = 0;
        while (num < len) {
            String s = data.substring(num, num + 2);
            System.out.println(s);
            total += Integer.parseInt(s, 16);
            num = num + 2;
        }
        /**
         * 用256求余最大是255,即16进制的FF
         */
        int mod = total % 256;
        String hex =String.format("%02X", mod);
        return hex;
    }
    String jiaoyuan = checksum("85"+datas);

     ----------------------------------------------------------------------------

    public static byte[] getXOR(byte[] bytes, int len) {
        byte[] partBytes = new byte[len];
        System.arraycopy(bytes,0,partBytes,0,partBytes.length);
        //LogPlus.e("###hex:" + ByteUtil.bytes2HexStr(partBytes));
        final short POLYNOMIAL = 0x1021;
        final int INITIAL_REMAINDER = 0xA1EC;
        final int TOPBIT = 1 << (16 - 1);
        int remainder = INITIAL_REMAINDER;
        for (int ibyte = 0; ibyte < len; ++ibyte) {
            remainder ^= ((partBytes[ibyte]) << (16 - 8));
    
            for (int i = 8; i > 0; --i) {
                if ((remainder & TOPBIT) != 0) {
                    remainder = (remainder << 1) ^ POLYNOMIAL;
                } else {
                    remainder = (remainder << 1);
                }
            }
        }
        byte[] crcBytes = new byte[2];
        return ByteUtil.long2bytes(remainder, crcBytes, 0, 2);
    
    }
    // 计算校验和
    byte check = ByteUtil.getXOR(bytes, 0, bytes.length - 1);

    展开全文
  • 十六进制(Hex) 、 字节(Byte)、比特(bit) 十六进制(Hex):计算机中数据的一种表示方法,它由0-9,A-F组成,字母不区分大小写。与10进制的对应关系是:0-9对应0-9;A-F对应10-15。 官方语言以0x开始的数据表示...
    • 十六进制(Hex) 、 字节(Byte)、比特(bit)

      十六进制(Hex):计算机中数据的一种表示方法,它由0-9,A-F组成,字母不区分大小写。与10进制的对应关系是:0-9对应0-9;A-F对应10-15。
      官方语言以0x开始的数据表示16进制。0x01 意思是0 * 16^1 + 1 * 16^0 = 1。

      字节(Byte): 数据存储的基本单位。

      比特(bit): 计算机语言中表示数据信息的最小单位:0或1

    • 换算关系:

      1字节 = 8比特,即1个字节数据在计算机中可表示的范围在00000000~11111111之间。

      众所周知,在计算机语言中,一个二进制bit位要么是0,要么是1。所以,一个bit位最多能表示2种状态(2^1),即01

      那么2个bit位呢? 00,01,10,11 一共可以表示4种状态(2^2)。

      3个bit位可以表示:001,001,010,011,100,101,110,111 一共8种状态(2^3);

      以此类推,当我们有4个bit位时,最高可以表示出16种状态。

      然后就引申出了16进制(Hex):逢16进1

      所以,当我们想在计算机语言中表达出一个16进制数字时,得需要4个bit位。

      而1个Byte字节需要8个bit位,由此可见 byte和hex的换算关系:

      我们可以将一个Byte用两个Hex表示,同理,也可以将两个Hex转换为一个Byte

      基于这个原理,在Java中可以进行一些换算。

      单个byte和hex的转换:

          /**
           * 十六进制字符串 转 byte
           */
          public static byte hexToByte(String inHex) {
              return (byte) Integer.parseInt(inHex, 16);
          }
      
          /**
           * byte 转 十六进制
           */
          public static String byteToHex(byte b) {
              String hex = Integer.toHexString(b & 0xFF);
              if (hex.length() < 2) {
                  hex = "0" + hex;
              }
              return hex;
          }
          
      
    • 而更多的应用场景时byte数组:

          /**
           * 十六进制 转 bytes数组
           */
          public static byte[] hexStringToBytes(String hexString) {
              if (hexString == null || hexString.equals("")) {
                  return null;
              }
              hexString = hexString.toUpperCase().replace(" ", "");
              int length = hexString.length() / 2;
              char[] hexChars = hexString.toCharArray();
              byte[] d = new byte[length];
              for (int i = 0; i < length; i++) {
                  int pos = i * 2;
                  d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
              }
              return d;
          }
          
          /**
           * byte数组 转 十六进制
           */
          public static String bytesToHex(byte[] bytes) {
              StringBuffer sb = new StringBuffer();
              for (int i = 0; i < bytes.length; i++) {
                  String hex = Integer.toHexString(bytes[i] & 0xFF);
                  if (hex.length() < 2) {
                      sb.append(0);
                  }
                  sb.append(hex);
              }
              return sb.toString();
          }
      
    • 十进制和十六进制的转换就简单多了,调用系统api就行:

          /**
           * 十进制 转 十六进制
           */
          public static String encodeHEX(Integer numb) {
              return Integer.toHexString(numb);
          }
      
          /**
           * 十六进制 转 十进制
           */
          public static int hexToInt(String hex) {
              return Integer.parseInt(hex, 16);
          }
      

    参考博客

    展开全文
  • 1、byte[]数组中存的是十六进制需要转十进制 2、两个十六进制的byte需要组合成一个十进制,比如高位:0x01,低位:0x78 组合成0x0178转十进制 解决办法 /** * byte转为十进制int * @param bytes * @...

    在模拟modbus通信过程的时候,需要有如下转换过程

    1、byte[]数组中存的是十六进制需要转十进制

    2、两个十六进制的byte需要组合成一个十进制,比如高位:0x01,低位:0x78  组合成0x0178转十进制

    解决办法

        /**
    	 * byte转为十进制int
    	 * @param bytes
    	 * @return
    	 */
    	public static int byte2int(byte bytes){
    		// 将byte转换为8位二进制字符串 依赖 commons-lang-x.x.jar包
    		String binaryString = StringUtils.leftPad(Integer.toBinaryString(bytes & 0xff), 8, '0');
    		// 将二进制字符串转换为十进制整数值
    		int value = Integer.parseInt(binaryString, 2);
    		return value;
    	}
    	
    	/**
    	 * 两个十六进制转为十进制
    	 * @param b1 十六进制低位
    	 * @param b2 十六进制高位
    	 * @return
    	 */
    	public static int byteToInt(byte b1,byte b2){
    		int deci = (b1|b2<<8);
    		return deci;
    		
    	}
     

     

    欢迎关注微信公众号,公众号的好处是可以持续保持联系。

     

     

    展开全文
  • 二进制 十进制byte之间相互转换

    千次阅读 2016-01-29 15:04:22
    //二进制是1110 byte[] b=System.BitConverter.GetBytes(a);///转换为byte,b[0]就是14 BitArray ba=new BitArray(b);//ba[0]=false,ba[1]=true,ba[2]=true,ba[3]=true,ba[4]=false.....数组的低位也是二进制的低位 ...

    int a=14;//二进制是1110      //32位

    byte[] b=System.BitConverter.GetBytes(a);///转换为byte,b[0]就是14  //8位  

    BitArray ba=new BitArray(b);//ba[0]=false,ba[1]=true,ba[2]=true,ba[3]=true,ba[4]=false.....数组的低位也是二进制的低位///默认32长度的1位

    int v=System.BitConverter.ToInt32(b,0);//又得到14

    展开全文
  • Java中10进制转byte[]

    千次阅读 2016-09-29 10:43:36
    public static byte[] int2bytes(int n) { int temp1 = 0,temp2=0;  byte[] hex = new byte[2];  if(n  {  hex[1] = (byte) n;  }  else  { temp1 = n & 0xff; hex[1] = (by
  • byte[] b_t = System.BitConverter.GetBytes(30); int i = System.BitConverter.ToInt32(b_t,0);
  • 怎么说,最近使用ssm框架的时候,需要将文件成十六进制的字符串传入数据库,按照传统的sql,一个rs.getBinaryStream()还有rs.setBinaryStream()就可以了,可是在ssm里面就不能这么写的啦。要用纯java去遍历了。 ...
  • byte[] bt = new byte[64]; for(i=0;i;i++) { bt[i] = Convert.ToString(10, 16); } 我知道这个地方不对,我想表达的意思就是这样。 实在没分了,不知道有没有哪位大哥行行好,帮助下。 感谢,真诚感谢
  • 一个byte用8位表示其中第一位为符号位, ...我要将16进制转byte,如果小于0X7F可以用一个字节表示. 但是大于0X7F用一个字节会导致溢出。 我想知道两个16进制位到底是用几个字节表示。 java是如果保存16进制的数据的。
  • 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[]...
  • 字符/字符串本身没有涉及进制转换,也就是没有溢出,那么直接调用byte.Parse(“字符数字”)即可,如果大于255 会报错,也请别这么干。 string a = "10 67 65 83 67 65 68 69 32 84 111 112 333 111 103 121 32 86...
  • android byte数组转16进制byte转10进制

    千次阅读 2020-07-06 08:47:53
    byte数组16进制 /** * byte数组16进制字符串 * * @param bytes byte数组 * @return 16进制字符串 */ public static String byteArrayToHexStr(byte[] bytes) { String strHex; StringBuilder sb = new ...
  • 如何把一个十六进制byte数组十进制整数。 如 byte[2] = {0x01,0x00},即十六进制为0x0100,最终转为"256"? eg: byte[n] 转为十进制 for (int i = 0; i<n; i++) { result *= 256; result += byte[n-1-i]; }
  • 最近由于工作上的需要,遇到进制转换的问题。涉及到的进制主要是 十进制,十六进制,二进制中间的转换。还包括了一个字节数组 与十六进制字符串的互相转换。估计遇到蓝牙通信的朋友,应该用的上。
  • C++ 16进制转byte

    2021-02-25 17:00:41
    #include <...byte hex2byte(char hexstr[]); int main() { char hex[3] = "67"; cout << int(hex2byte(hex)); } byte hex2byte(char hexstr[]) { byte h = hexstr[0]; byte l = hexst
  • C# byte和10进制、16进制相互转换

    千次阅读 2019-04-16 17:51:35
    var SRMP = new byte[4]; Array.Copy(Encoding.UTF8.GetBytes(1.ToString("x2")), SRMP, Encoding.UTF8.GetBytes(1.ToString("x2")).Length); Array.Copy(Encoding.UTF8.GetBytes((j + 1).ToString("x2")), 0, SRMP....
  • 此工具用于将16进制字符串转换成10进制byte数组
  • 十进制->十六进制 Byte bytes[]={0xA6,0x27,0x0A}; NSString *strIdL = [NSString stringWithFormat:@"%@",[[NSString alloc] initWithFormat:@"%02lx",(long)bytes[0]]]; 十六进制->十进制 NSString *re...
  • //十进制转二进制 Console.WriteLine(Convert.ToString(69, 2)); //十进制转八进制 Console.WriteLine(Convert.ToString(69, 8)); //十进制转十六进制 Console.WriteLine(Convert.ToString(69, 16)); //二进制...
  • 项目中遇到将字节数据文件解析成可展示的十进制,经过调查和测试得出下面的转换方法 1、将byte值转换为二进制字符串: byte byteValue = -1; // 将byte转换为8位二进制字符串 依赖 commons-lang-x.x.jar包 String ...
  • 16进制byte的转换

    万次阅读 2016-09-21 16:28:31
    新添加两种方式: private static final char[] HEX_CHAR = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};... public static String bytesToHex(byte[]...
  • 十六进制转byte变负数

    2016-07-15 19:43:00
    public static void main(String[] args) { byte test = -128; System.out.println(test==(byte)0x80); } 转载于:https://www.cnblogs.com/xxdfly/p/5674649.html
  • & 0xFF byte字节数组转换为十进制

    千次阅读 2018-08-24 16:32:48
    byte[] b = new byte[2]; b[0] = -12; byte 1个字节 char 2个字节 short 2个字节  ...计算机存储数据机制:正数存储的二进制原码,负数存储的是二进制的补码。 补码是负数的绝对值反码加...
  • byte[3] = new byte[]{0x00,0x00,0x22}为例: public static int bytes2Int(byte[] bytes) { int num = bytes[2] & 0xFF; num |= ((bytes[1] << 8) & 0xFF00); num |= ((bytes[0] << ...
  • java工具类 : string10进制sacii byte数组、 10进制sacii byte数组16进制字符数组、 16进制字符数组16进制byte数组、 string与BCD互等方法,包含多个转换方法, 足够满足日常解包组包需求
  • Java 10进制byte数组与16进制byte数组互 及 在DES加解密中的使用
  • string字符串——>16进制byte[]字节数组 public static byte[] StringToHexBytes(String s) { s = s.Replace(" ", ""); s = s.Replace("#", ""); byte[] b_ASCII = Enc...
  • byte[] 转十进制

    2015-07-24 13:08:00
    byte b1 = 1; //一个byte的变量,作为转换后的高8位,假设初值为 0000 0001 byte b2 = 2; //一个byte的变量,作为转换后的低8位,假设初值为 0000 0010 s = (short)(s ^ b1); //将b1赋给s的低8位 s ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 91,555
精华内容 36,622
关键字:

十进制转byte