JAVA十六进制操作工具类

于 2024-08-02 17:01:05 发布
阅读量281 收藏
点赞数 3
文章标签： java iot 物联网 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangdechao1833716/article/details/140875108
版权

物联网类的系统开发，涉及与低功耗终端设备间的对接，经常会用到16进制之间转化问题，如byte[]转为16进制字符串，BCD码转字节数组等。本工具类依赖hutool，请注意先导入此包。

import cn.hutool.core.util.StrUtil;

import java.util.Base64;
import java.util.Locale;

public class HexConvertUtil {

    /**
     * 一个字节包含位的数量 8
     */
    private static final int BITS_OF_BYTE = 8;

    /**
     * 多项式
     */
    private static final int POLYNOMIAL = 0xA001;

    /**
     * 初始值
     */
    private static final int INITIAL_VALUE = 0xFFFF;

    private final static char[] mChars = "0123456789ABCDEF".toCharArray();
    private final static String mHexStr = "0123456789ABCDEF";

    /**
     * 检查16进制字符串是否有效
     *
     * @param sHex String 16进制字符串
     * @return boolean
     */
    public static boolean checkHexStr(String sHex) {
        String sTmp = sHex.trim().replace(" ", "").toUpperCase(Locale.US);
        int iLen = sTmp.length();

        if (iLen > 1 && iLen % 2 == 0) {
            for (int i = 0; i < iLen; i++)
                if (!mHexStr.contains(sTmp.substring(i, i + 1)))
                    return false;
            return true;
        } else
            return false;
    }

    /**
     * 字符串转换成十六进制字符串
     *
     * @param str String 待转换的ASCII字符串
     * @return String 每个Byte之间空格分隔，如: [61 6C 6B]
     */
    public static String str2HexStr(String str) {
        StringBuilder sb = new StringBuilder();
        byte[] bs = str.getBytes();

        for (int i = 0; i < bs.length; i++) {
            sb.append(mChars[(bs[i] & 0xFF) >> 4]);
            sb.append(mChars[bs[i] & 0x0F]);
            sb.append(' ');
        }
        return sb.toString().trim();
    }

    /**
     * 十六进制字符串转换成 ASCII字符串
     *
     * @param hexStr String Byte字符串
     * @return String 对应的字符串
     */
    public static String hexStr2Str(String hexStr) {
        hexStr = hexStr.trim().replace(" ", "").toUpperCase(Locale.US);
        char[] hexs = hexStr.toCharArray();
        byte[] bytes = new byte[hexStr.length() / 2];
        int iTmp;
        for (int i = 0; i < bytes.length; i++) {
            iTmp = mHexStr.indexOf(hexs[2 * i]) << 4;
            iTmp |= mHexStr.indexOf(hexs[2 * i + 1]);
            bytes[i] = (byte) (iTmp & 0xFF);
        }
        return new String(bytes);
    }

    /**
     * bytes转换成十六进制字符串
     *
     * @param b    byte[] byte数组
     * @param iLen int 取前N位处理 N=iLen
     * @return String 每个Byte值之间空格分隔
     */
    public static String byte2HexStr(byte[] b, int iLen) {
        StringBuilder sb = new StringBuilder();
        for (int n = 0; n < iLen; n++) {
            sb.append(mChars[(b[n] & 0xFF) >> 4]);
            sb.append(mChars[b[n] & 0x0F]);
            sb.append(' ');
        }
        return sb.toString().trim().toUpperCase(Locale.US);
    }

    /**
     * bytes字符串转换为Byte值
     *
     * @param src String Byte字符串，每个Byte之间没有分隔符(字符范围:0-9 A-F)
     * @return byte[]
     */
    public static byte[] hexStr2Bytes(String src) {
        /*对输入值进行规范化整理*/
        src = src.trim().replace(" ", "").toUpperCase(Locale.US);
        //处理值初始化
        int m, n;
        int iLen = src.length() / 2; //计算长度
        byte[] ret = new byte[iLen]; //分配存储空间

        for (int i = 0; i < iLen; i++) {
            m = i * 2 + 1;
            n = m + 1;
            ret[i] = (byte) (Integer.decode("0x" + src.substring(i * 2, m) + src.substring(m, n)) & 0xFF);
        }
        return ret;
    }

    /**
     * String的字符串转换成unicode的String
     *
     * @param strText String 全角字符串
     * @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");
            else // 低位在前面补00
                str.append("\\u00");
            str.append(strHex);
        }
        return str.toString();
    }

    /**
     * unicode的String转换成String的字符串
     *
     * @param hex String 16进制值字符串 （一个unicode为2byte）
     * @return String 全角字符串
     */
    public static String unicodeToString(String hex) {
        int t = hex.length() / 6;
        int iTmp;
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < t; i++) {
            String s = hex.substring(i * 6, (i + 1) * 6);
            // 将16进制的string转为int
            iTmp = (Integer.valueOf(s.substring(2, 4), 16) << 8) | Integer.valueOf(s.substring(4), 16);
            // 将int转换为字符
            str.append(new String(Character.toChars(iTmp)));
        }
        return str.toString();
    }

    /**
     * 将bytes转为16进制string
     *
     * @param byteArray
     * @return
     */
    public static String byteArrayToHexStr(byte[] byteArray) {
        if (byteArray == null) {
            return null;
        }
        char[] hexArray = "0123456789ABCDEF".toCharArray();
        char[] hexChars = new char[byteArray.length * 2];
        for (int j = 0; j < byteArray.length; j++) {
            int v = byteArray[j] & 0xFF;
            hexChars[j * 2] = hexArray[v >>> 4];
            hexChars[j * 2 + 1] = hexArray[v & 0x0F];
        }
        return new String(hexChars);
    }

    /**
     * 将指定字符串src，以每两个字符分割转换为16进制形式
     * 如："2B44EFD9" --> byte[]{0x2B, 0x44, 0xEF, 0xD9}
     *
     * @param src String
     * @return byte[]
     */
    public static byte[] hexString2Bytes(String src) {

        byte[] ret = new byte[src.length() / 2];
        byte[] tmp = src.getBytes();
        for (int i = 0; i < tmp.length / 2; i++) {
            ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
        }
        return ret;
    }

    /**
     * 将两个ASCII字符合成一个字节；
     * 如："EF"--> 0xEF
     *
     * @param src0 byte
     * @param src1 byte
     * @return byte
     */
    public static byte uniteBytes(byte src0, byte src1) {
        byte _b0 = Byte.decode("0x" + new String(new byte[]{src0})).byteValue();
        _b0 = (byte) (_b0 << 4);
        byte _b1 = Byte.decode("0x" + new String(new byte[]{src1})).byteValue();
        byte ret = (byte) (_b0 ^ _b1);
        return ret;
    }

    /**
     * 拆分数组
     *
     * @param start  开始下标
     * @param length 拆分长度
     * @param bytes  需要拆分的数组
     * @return
     */
    public static byte[] split(int start, int length, byte[] bytes) {
        byte[] by = new byte[length];
        System.arraycopy(bytes, start, by, 0, length);
        return by;
    }

    /**
     * bytes转换成十六进制字符串 不带空格
     *
     * @param b byte数组
     * @return String 每个Byte值之间空格分隔 如: 616C6B
     */
    public static String bytes2HexStr1(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);
        }
        return sb.toString().toUpperCase().trim();
    }

    /**
     * 将字节数组合并为字符串.<br>
     * 本方法为取出每一位字节,直接作为字符处理,而不是作为ASCII值<br>
     * 例如:字节49->字符49,而不是字节49->字符1(字符1的ASCII值是49)
     *
     * @param byteArray
     * @return
     */
    public static String byteArray2String(byte[] byteArray) {

        // 合并后的字符串
        StringBuffer sb = new StringBuffer(byteArray.length);
        // 遍历字节数组
        for (int i = 0, length = byteArray.length; i < length; i++) {

            sb.append(byteArray[i]);
        }

        return sb.toString();
    }

    /**
     * BCD码转字节数组
     *
     * @param bcd bcd码
     * @return
     */
    public static byte[] bcd2ByteArray(byte[] bcd) {

        // 转换后字节数组
        byte[] byteArray = new byte[bcd.length * 2];
        // 遍历BCD码
        for (int i = 0, length = bcd.length; i < length; i++) {

            byteArray[i * 2] = (byte) ((bcd[i] & 0xf0) >> 4);
            byteArray[i * 2 + 1] = (byte) (bcd[i] & 0x0f);
        }

        return byteArray;
    }

    /**
     * 将字节数组(0<长度<=8)合并为长整型
     *
     * @param byteArray
     * @return
     */
    public static long byteArray2Long(byte[] byteArray) {

        // 字节数组长度
        int length = byteArray.length;

        if (length == 0) {
            throw new RuntimeException("运行异常");
        } else if (length > 8) {
            throw new RuntimeException("运行异常");
        } else {
            // 获取最末位的字节
            long l = byte2Long(byteArray[length - 1]);

            // 遍历字节数组,从倒数第二位向前
            for (int index = length - 1; index > 0; index--) {

                // 数组的第(index-1)位,要向左移(length-index)字节
                l = l | byte2Long(byteArray[index - 1]) << ((length - index) * 8);
            }

            return l;
        }
    }

    public static long byte2Long(byte b) {

        return (b & 0xff);
    }

    /**
     * 字节数组转为普通字符串（ASCII对应的字符）
     *
     * @param bytearray byte[]
     * @return String
     */
    public static String bytetoString(byte[] bytearray) {
        String result = "";
        char temp;

        int length = bytearray.length;
        for (int i = 0; i < length; i++) {
            temp = (char) bytearray[i];
            result += temp;
        }
        return result;
    }

    /**
     * 将字节数组(0<长度<=4)合并为整型
     *
     * @param byteArray
     * @return
     */
    public static int byteArray2Int(byte[] byteArray) {

        // 字节数组长度
        int length = byteArray.length;

        if (length == 0) {
            throw new RuntimeException("运行异常");
        } else if (length > 4) {
            throw new RuntimeException("运行异常");
        } else {
            // 获取最末位的字节
            int i = byte2Int(byteArray[length - 1]);

            // 遍历字节数组,从倒数第二位向前
            for (int index = length - 1; index > 0; index--) {

                // 数组的第(index-1)位,要向左移(length-index)字节
                i = i | (byte2Int(byteArray[index - 1]) << ((length - index) * 8));
            }

            return i;
        }
    }

    /**
     * 将无符号字节(即8位均为数据的字节)转换为有符号的整型;
     *
     * @param b 无符号字节
     * @return
     */
    public static int byte2Int(byte b) {

        return (b & 0xff);
    }

    /**
     * 字节数组转BCD码,字节数组长度必须为2的倍数
     *
     * @param byteArray
     * @return
     */
    public static byte[] byteArray2BCD(byte[] byteArray) {

        // 字节数组长度
        int byteArrayLength = byteArray.length;
        // 若长度不为2的倍数,则抛出异常
        if (byteArrayLength % 2 != 0) {
            throw new RuntimeException("运行异常");
        }

        // BCD码
        byte[] bcd = new byte[byteArrayLength / 2];
        // 遍历字节数组
        for (int i = 0, length = bcd.length; i < length; i++) {

            // 前字节向左位移4位,与上后字节
            bcd[i] = (byte) (((byte) (byteArray[i * 2] << 4)) | (byteArray[i * 2 + 1]));
        }

        return bcd;
    }

    /**
     * 将字符串拆分为字节数组.
     * 本方法为取出每一个字符,将其直接转为byte,而非使用ASCII值进行转换
     * 例如:字符1->字节1,而不是字符1->字节49(字符1的ASCII值是49)
     *
     * @param str
     * @return
     */
    public static byte[] string2ByteArray(String str) {

        // 拆分后的字节数组
        byte[] byteArray = new byte[str.length()];
        // 遍历字符串每一个字符
        for (int i = 0, length = str.length(); i < length; i++) {

            byteArray[i] = Byte.valueOf(str.charAt(i) + "");
        }

        return byteArray;
    }

    /**
     * 将整型拆分为长度为4的字节数组
     *
     * @param i
     * @return
     */
    public static byte[] int2ByteArray(int i) {

        // 拆分后的字节数组
        byte[] byteArray = new byte[4];
        // 数组长度
        int length = byteArray.length;

        // 遍历数组
        for (int index = 1; index <= length; index++) {

            // 数组的第(index-1)位,要向右移(length-index)字节
            byteArray[index - 1] = (byte) (i >> ((length - index) * 8));
        }

        return byteArray;
    }

    /**
     * 将长整型拆分为长度为8的字节数组
     *
     * @param l
     * @return
     */
    public static byte[] long2ByteArray(long l) {

        // 拆分后的字节数组
        byte[] byteArray = new byte[8];
        // 数组长度
        int length = byteArray.length;

        // 遍历数组
        for (int index = 1; index <= length; index++) {

            // 数组的第(index-1)位,要向右移(length-index)字节
            byteArray[index - 1] = (byte) (l >> ((length - index) * 8));
        }

        return byteArray;
    }

    public static byte[] intToBytes(int source, int length) {
        byte[] b = new byte[length];
        for (int i = 0; i < length; i++) {
            b[i] = (byte) (source >> 8 * (length - i - 1) & 0xFF);
        }
        return b;
    }

    /**
     * base64字符串转16进制字符串
     *
     * @param base64Str
     * @return
     */
    public static byte[] base64ToHexByte(String base64Str) {
        if (StrUtil.isEmpty(base64Str)) {
            throw new RuntimeException("base64字符串不能为空！");
        }
        return Base64.getDecoder().decode(base64Str);
    }

    public static String byteArrToBinStr(byte[] b) {
        StringBuilder result = new StringBuilder();
        for (byte value : b) {
            String str = Long.toString(value & 0xff, 2);
            if (str.length() < 8) {
                StringBuilder zeroStr = new StringBuilder();
                for (int i = 0; i < (8 - str.length()); i++) {
                    zeroStr.append(0);
                }
                str = zeroStr + str;
            }
            result.append(str).append(",");
        }
        return result.substring(0, result.length() - 1);
    }

    public static int crc16(byte[] bytes) {
        int res = INITIAL_VALUE;
        for (int data : bytes) {
            res = res ^ data;
            for (int i = 0; i < BITS_OF_BYTE; i++) {
                res = (res & 0x0001) == 1 ? (res >> 1) ^ POLYNOMIAL : res >> 1;
            }
        }
        return revert(res);
    }

    private static int revert(int src) {
        int lowByte = (src & 0xFF00) >> 8;
        int highByte = (src & 0x00FF) << 8;
        return lowByte | highByte;
    }

    public static byte crc8(byte[] data) {
        byte crc = 0;
        for (byte datum : data) {
            crc ^= datum;
            for (int i = 0; i < 8; i++) {
                if ((crc & 0x80) != 0) {
                    crc = (byte) ((crc) << 1);
                    crc ^= (byte) 0x107;
                } else {
                    crc = (byte) ((crc) << 1);
                }
            }
        }
        return crc;
    }
}
wanDCFly
关注
Hex java十六进制工具类
07-31
Hex java十六进制工具类
Java实现的进制转换工具类完整示例
08-27
主要介绍了Java实现的进制转换工具类,结合完整实例形式分析了Java实现二进制、十六进制、字符串、数组等相关转换操作技巧,需要的朋友可以参考下
ByteUtil 16进制数据流和字符串的相互转换工具类
05-28
此工具应用于Android端与硬件通过socket通信时，需要传递的字节流，用于16进制数据流和字符串的相互转换工具类
Java进制转换工具类详解：从十进制到任意进制的轻松转换
爱媳妇儿爱编程
05-05 2421
本文主要写进制转换的工具类和二进制相加的算法。具体的各个进制转换的方法讲解见上一篇：。
hutool常见的类型转换方法
fantasyfzg的博客
12-06 7023
hutool
Java byte[ ]与十六进制字符串相互转换
keithxiaoy
07-11 3996
很多时候我们需要将字节数组转化为16进制字符串来保存，在很多加密的场景中，例如保存密钥等都需要将 Byte[ ] 转换为 String 。因为 Byte[ ] ，除了写入文件或者以二进制的形式写入数据库以外，无法直接转为为字符串。而输入密钥等操作，却不可能直接让用户输入一长串的 Byte[ ] ，我们会让用户输入 String ，所以这种需求就出现了。 一、工具类 package co...
hutool(字符串工具-StrUtil与类型转换工具类-Convert)
热门推荐
madleep的博客
11-03 1万+
不得不提一下这个方法，有人说String有了subString你还写它干啥，我想说subString方法越界啥的都会报异常，你还得自己判断，难受死了，我把各种情况判断都加进来了，而且index的位置还支持负数哦，-1表示最后一个字符（这个思想来自于Python，如果学过Python的应该会很喜欢的），还有就是如果不小心把第一个位置和第二个位置搞反了，也会自动修正（例如想截取第4个和第2个字符之间的部分也是可以的哦~） 举个栗子。因为字符串牵涉到编码问题，因此必须传入编码对象，此处使用UTF-8编码。
进制转化工具类
weixin_44684812的博客
08-17 1071
进制转化工具类 import cn.hutool.core.convert.Convert; /** * 进制转化工具 */ public class ParseSystemUtil { /** * 将二进制转换成16进制 * * @param buf * @return */ public static String parseByte2HexStr(byte buf[]) { StringBuffer sb = n
java进制转换工具类
06-09
二进制数组转换为二进制字符串 将二进制数组转换为十六进制字符串 将十六进制转换为二进制字节数组 将十六进制转换为二进制字符串
java socket处理硬件传过来的16进制数据的工具类
10-13
java socket处理硬件传过来的16进制数据的工具类，包含大小端转换、byte[]数组转换为16进制的字符串、byte[]转ByteBuffer、16进制字符串转换为byte数组等
十进制转十六进制包含大小端设置_大小端_matlab_十进制_十六进制_
09-30
本文将详细讨论大小端模式，并通过MATLAB实现一个将十进制数转换为十六进制数的函数，同时允许用户选择大小端模式。 首先，我们来解释一下大小端模式。在多字节的数据类型（如32位整数）中，最高有效位（MSB）和...
JAVA 十六进制与字符串的转换浅谈
hdxx2022的博客
08-01 5391
笔者前几日在开服过程中需要将字符串转化成为16进制的字符串,在网上找到了一些方法尝试之后,均发现存在一个问题-->字符串转为16进制后再转回来,英文正常,中文出现乱码。笔者前几日在开服过程中需要将字符串转化成为16进制的字符串,在网上找到了一些方法尝试之后,均发现存在一个问题-->字符串转为16进制后再转回来,英文正常,中文出现乱码。1)在将字符串转为16进制之前先进行一次转化,先将其转化成为Unicode编码(相当于把中文用英文字符代替),在转化成为16进制。*字符串转为16进制。*16进制转为字符串。
字节数组转16进制
cache007的专栏
10-16 922
public String bytesToHexString(byte[] src)     {         StringBuilder stringBuilder = new StringBuilder("");         if (src == null || src.length         {             return null;         }
Java中一种高效的 字符串转十六进制的 方法
northcastle的博客
06-07 1343
字符串转十六进制，高效
java_16进制工具类
java之书-资源
04-23 317
16进制工具类
Java十六进制工具类
SYjiduan的博客
08-25 812
十六进制字符串转字节数组 public static byte[] hexStrToBinaryStr(String hexString) { if (StringUtils.isEmpty(hexString)) { return null; } hexString = hexString.replaceAll(" ", ""); int len = hexString.length(); .
java基础之byte转换工具类
csdnzhang365的博客
09-14 4619
java 字节转换
Java 将字节数组转化为16进制的多种方案
qq_24954199的博客
10-28 657
很多时候我们需要将字节数组转化为16进制字符串来保存，尤其在很多加密的场景中，例如保存密钥等。因为字节数组，除了写入文件或者以二进制的形式写入数据库以外，无法直接转为为字符串，因为字符串结尾有\0，当然肯定还有其他原因。 下面提供几种Java中使用的方案： 方案一：直接利用BigInteger的方法，应该是最简单的方案了。 [java] view plainc
java十六进制转十进制工具类
最新发布
08-09
下面是一个Java的十六进制转十进制的工具类： ```java public class HexToDecimal { public static int hexToDecimal(String hex) { int decimal = 0; String digits = "0123456789ABCDEF"; hex = hex....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值