java 浮点、整形、布尔、字符串 转 16进制

    /*
     * @param pdataType  数据类型
     * val 需要转换的数据
     */
  
    public Object  main(Integer pdataType,Object val) throws UnsupportedEncodingException {
        String v = null;
        switch (pdataType){
            default:
                break;
            case 0:
                //(浮点)
                long l = Double.doubleToRawLongBits(Double.parseDouble(val.toString()));
                String s = Long.toHexString(l);

                byte[] bytes = Hex.str16ToByte(s);
                if(null == bytes){
                    v = HexStringTool.numToStr16(8, Double.parseDouble(val.toString()));
                }else{
                    byte[] converting = converting(bytes);
                    v = Hex.byte2HexStr(converting);
                    v = v.toLowerCase();
                }
                break;
            case 1:
                //(整型)
                v = HexStringTool.numToStr16(8, Long.parseLong(val.toString()));
                break;
            case 2:
                //(布尔)
                v = HexStringTool.numToStr16(1, Integer.parseInt(val.toString()));
                break;
            case 3:
                //(字符串)
                String v16 = String.format("%x", new BigInteger(1, val.toString().getBytes("utf-8")));
                int vlen = v16.length();
                String vlen16 = HexStringTool.numToStr16(1, vlen/2);
                v = vlen16 + v16;
                break;
        }
        return v;
    }

    // 基于字节  大端转小端/ 小端转大端
    public static byte[] converting(byte[] value) {
        final int length = value.length;
        byte[] res = new byte[length];
        for(int i = 0; i < length; i++) {
            res[length - i - 1] = value[i];
        }
        return res;
    }
    

Hex

import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;

public class Hex {
    /**
     * 用于建立十六进制字符的输出的小写字符数组
     */
    private static final char[] DIGITS_LOWER = {'0', '1', '2', '3', '4', '5',
            '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    /**
     * 用于建立十六进制字符的输出的大写字符数组
     */
    private static final char[] DIGITS_UPPER = {'0', '1', '2', '3', '4', '5',
            '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};


    private static ByteBuffer buffer = ByteBuffer.allocate(8);

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

        char[] chars = "0123456789ABCDEF".toCharArray();
        StringBuilder sb = new StringBuilder("");
        byte[] bs = str.getBytes();
        int bit;

        for (int i = 0; i < bs.length; i++) {
            bit = (bs[i] & 0x0f0) >> 4;
            sb.append(chars[bit]);
            bit = bs[i] & 0x0f;
            sb.append(chars[bit]);
            sb.append(' ');
        }
        return sb.toString().trim();
    }

    /**
     * 十六进制转换字符串
     *
     * @param hexStr Byte字符串(Byte之间无分隔符 如:[616C6B])
     * @return String 对应的字符串
     */
    public static String hexStr2Str(String hexStr) {
        String str = "0123456789ABCDEF";
        char[] hexs = hexStr.toCharArray();
        byte[] bytes = new byte[hexStr.length() / 2];
        int n;

        for (int i = 0; i < bytes.length; i++) {
            n = str.indexOf(hexs[2 * i]) * 16;
            n += str.indexOf(hexs[2 * i + 1]);
            bytes[i] = (byte) (n & 0xff);
        }
        return new String(bytes);
    }

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


    /**
     * bytes字符串转换为Byte值
     *
     * @param src Byte字符串，每个Byte之间没有分隔符
     * @return byte[]
     */
    public static byte[] hexStr2Bytes(String src) {
        int m = 0, n = 0;
        int l = src.length() / 2;
        System.out.println(l);
        byte[] ret = new byte[l];
        for (int i = 0; i < l; i++) {
            m = i * 2 + 1;
            n = m + 1;
            String tmp = "0x" + src.substring(i * 2, m) + src.substring(m, n);
            ret[i] = Byte.decode(tmp);
        }
        return ret;
    }

    /**
     * bytes字符串转换为Byte值
     *
     * @param hexString
     * @return
     */
    public static byte[] hexToBytes(String hexString) {
        if (hexString == null || hexString.equals("")) {
            return null;
        }

        int length = hexString.length() / 2;
        char[] hexChars = hexString.toCharArray();
        byte[] bytes = new byte[length];
//        String hexDigits = "0123456789abcdefABCDEF";
        String hexDigits = "0123456789abcdef";
        for (int i = 0; i < length; i++) {
            int pos = i * 2; // 两个字符对应一个byte
            int h = hexDigits.indexOf(hexChars[pos]) << 4; // 注1
            int l = hexDigits.indexOf(hexChars[pos + 1]); // 注2
            if (h == -1 || l == -1) { // 非16进制字符
                return null;
            }
            bytes[i] = (byte) (h | l);
        }
        return bytes;
    }

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

    /**
     * unicode的String转换成String的字符串
     *
     * @param hex 16进制值字符串 （一个unicode为2byte）
     * @return String 全角字符串
     */
    public static String unicodeToString(String hex) {
        int t = hex.length() / 6;
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < t; i++) {
            String s = hex.substring(i * 6, (i + 1) * 6);
            // 高位需要补上00再转
            String s1 = s.substring(2, 4) + "00";
            // 低位直接转
            String s2 = s.substring(4);
            // 将16进制的string转为int
            int n = Integer.valueOf(s1, 16) + Integer.valueOf(s2, 16);
            // 将int转换为字符
            char[] chars = Character.toChars(n);
            str.append(new String(chars));
        }
        return str.toString();
    }


    /**
     * 将字节数组转换为十六进制字符数组
     *
     * @param data byte[]
     * @return 十六进制char[]
     */
    public static char[] encodeHex(byte[] data) {
        return encodeHex(data, true);
    }

    /**
     * 将字节数组转换为十六进制字符数组
     *
     * @param data        byte[]
     * @param toLowerCase <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式
     * @return 十六进制char[]
     */
    public static char[] encodeHex(byte[] data, boolean toLowerCase) {
        return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
    }

    /**
     * 将字节数组转换为十六进制字符数组
     *
     * @param data     byte[]
     * @param toDigits 用于控制输出的char[]
     * @return 十六进制char[]
     */
    protected static char[] encodeHex(byte[] data, char[] toDigits) {
        int l = data.length;
        char[] out = new char[l << 1];
        // two characters form the hex value.
        for (int i = 0, j = 0; i < l; i++) {
            out[j++] = toDigits[(0xF0 & data[i]) >>> 4];
            out[j++] = toDigits[0x0F & data[i]];
        }
        return out;
    }

    /**
     * 将字节数组转换为十六进制字符串
     *
     * @param data byte[]
     * @return 十六进制String
     */
    public static String encodeHexStr(byte[] data) {
        return encodeHexStr(data, true);
    }

    /**
     * 将字节数组转换为十六进制字符串
     *
     * @param data        byte[]
     * @param toLowerCase <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式
     * @return 十六进制String
     */
    public static String encodeHexStr(byte[] data, boolean toLowerCase) {
        return encodeHexStr(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
    }

    /**
     * 将字节数组转换为十六进制字符串
     *
     * @param data     byte[]
     * @param toDigits 用于控制输出的char[]
     * @return 十六进制String
     */
    protected static String encodeHexStr(byte[] data, char[] toDigits) {
        return new String(encodeHex(data, toDigits));
    }

    /**
     * 将十六进制字符数组转换为字节数组
     *
     * @param data 十六进制char[]
     * @return byte[]
     * @throws RuntimeException 如果源十六进制字符数组是一个奇怪的长度，将抛出运行时异常
     */
    public static byte[] decodeHex(char[] data) {

        int len = data.length;

        if ((len & 0x01) != 0) {
            throw new RuntimeException("Odd number of characters.");
        }

        byte[] out = new byte[len >> 1];

        // two characters form the hex value.
        for (int i = 0, j = 0; j < len; i++) {
            int f = toDigit(data[j], j) << 4;
            j++;
            f = f | toDigit(data[j], j);
            j++;
            out[i] = (byte) (f & 0xFF);
        }

        return out;
    }

    /**
     * 将十六进制字符转换成一个整数
     *
     * @param ch    十六进制char
     * @param index 十六进制字符在字符数组中的位置
     * @return 一个整数
     * @throws RuntimeException 当ch不是一个合法的十六进制字符时，抛出运行时异常
     */
    protected static int toDigit(char ch, int index) {
        int digit = Character.digit(ch, 16);
        if (digit == -1) {
            throw new RuntimeException("Illegal hexadecimal character " + ch
                    + " at index " + index);
        }
        return digit;
    }

    /**
     * float -> byte[]
     *
     * @param data
     * @return
     */
    public static byte[] getBytes(float data) {
        int intBits = Float.floatToIntBits(data);
        return intToByteArray(intBits);
    }

    /**
     * double -> byte[]
     *
     * @param data
     * @return
     */
    public static byte[] getBytes(double data) {
        long longBits = Double.doubleToLongBits(data);
        return longToBytes(longBits);
    }

    /**
     * byte[] -> float
     *
     * @param bytes
     * @return
     */
    public static float getFloat(byte[] bytes) {
        return Float.intBitsToFloat(getInt(bytes));
    }

    public static int getInt(byte[] bytes) {
        return (0xff & bytes[0]) | (0xff00 & (bytes[1] << 8)) | (0xff0000 & (bytes[2] << 16)) | (0xff000000 & (bytes[3] << 24));
    }

    /**
     * byte[] -> double
     *
     * @return
     */
    public static double getDouble(byte[] b) {
        long l;
        l = b[0];
        l &= 0xff;
        l |= ((long) b[1] << 8);
        l &= 0xffff;
        l |= ((long) b[2] << 16);
        l &= 0xffffff;
        l |= ((long) b[3] << 24);
        l &= 0xffffffffL;
        l |= ((long) b[4] << 32);
        l &= 0xffffffffffL;
        l |= ((long) b[5] << 40);
        l &= 0xffffffffffffL;
        l |= ((long) b[6] << 48);
        l &= 0xffffffffffffffL;
        l |= ((long) b[7] << 56);
        return Double.longBitsToDouble(l);
    }

    /**
     * 字节数组字符串 -> double
     *
     * @param bytesStr
     * @return
     */
    public static double getDouble(String bytesStr) {
        byte[] aa = hexToBytes(bytesStr.toLowerCase());
        return getDouble(aa);
    }


    /**
     * 字节数组字符串 -> float
     *
     * @param bytesStr
     * @return
     */
    public static float getFloat(String bytesStr) {
        byte[] aa = hexToBytes(bytesStr.toLowerCase());

        return getFloat(aa);
    }

    /**
     * 16进制字符串 -> byte数组
     */
    public static byte[] str16ToByte(String str16) {

        int len = str16.length();
        if (len % 2 > 0) {
            return null;
        }

        byte res[] = new byte[len / 2];

        for (int i = 0; i < len / 2; i++) {
            String tmp = str16.substring(i*2, (i + 1) * 2);
            byte t[] = hexToBytes(tmp);
            res[i] = t[0];
        }
        return res;
    }


    public static void main(String args[]) throws UnsupportedEncodingException {

        String hh = "86";
        byte[] bytehh = hexToBytes(hh);
        int bb = Integer.parseInt("86", 16);
        byte[] cc = intToByteArray(bb);
        byte dd = intToByte(bb);
        System.out.println("00000");

        int parseInt = Integer.parseInt("cc", 16);

        byte[] cc1 = intToByteArray(parseInt);
        System.out.println(parseInt);
        byte dd1 = intToByte(parseInt);
        byte dd3 = (byte) 0x86;

        byte dd4[] = new byte[1];
        dd4[0] = dd3;

        byte[] dd44 = hexToBytes("86");

        byte[] dd55 = str16ToByte("86371616");

        System.out.println();
        String messageContent = ByteUtil.binary(dd4, 16);
        String hexString = Integer.toHexString(parseInt);
        System.out.println(hexString);


    }

    public static byte[] intToByteArray(int a) {
        return new byte[]{
                (byte) ((a >> 24) & 0xFF),
                (byte) ((a >> 16) & 0xFF),
                (byte) ((a >> 8) & 0xFF),
                (byte) (a & 0xFF)
        };
    }

    public static byte intToByte(int a) {
        return (byte) (a & 0xFF);
    }

    public static byte[] longToBytes(long x) {
        buffer.putLong(0, x);
        return buffer.array();
    }


}

HexStringTool

import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;

public class HexStringTool {


    private static final char[] HEX_CHAR_ARR = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    private static final String HEX_STR = "0123456789abcdef";

    //对字符串，进行分组，转化为List
    public static List<String> getStrList(String str16, int frontLen, int size, int length) {
        List<String> list = new ArrayList<String>();
        String content = str16.substring(frontLen);
        String tem = "";
        for (int index = 0; index < size; index++) {
            tem = content.substring(0, length);
            content = content.substring(length);
            list.add(tem);
        }
        return list;
    }

    //对字符串，进行分组，转化为List(字符串数据类型转化专用)
    public static List<String> getStrList(String str16, int frontLen, int size, int totalLen, int lenLen) {
        List<String> list = new ArrayList<>();
        String content = str16.substring(frontLen);
        String tem = "";
        for (int index = 0; index < size; index++) {
            String len16 = content.substring(totalLen * 2, (totalLen + lenLen) * 2);
            int len = Integer.parseInt(len16, 16);
            int length = (totalLen + lenLen + len) * 2;
            tem = content.substring(0, length);
            content = content.substring(length);
            list.add(tem);
        }
        return list;
    }

    //字符串转换unicode
    public static String string2Unicode(String string) {
        StringBuffer unicode = new StringBuffer();
        for (int i = 0; i < string.length(); i++) {
            // 取出每一个字符
            char c = string.charAt(i);
            // 转换为unicode
            unicode.append("\\u" + Integer.toHexString(c));
        }
        return unicode.toString();
    }

    //字符串转化成为16进制字符串
    public static String strTo16(String s) {
        String str = "";
        for (int i = 0; i < s.length(); i++) {
            int ch = (int) s.charAt(i);
            String s4 = Integer.toHexString(ch);
            str = str + s4;
        }
        return str;
    }

    //16进制转换成为string类型字符串
    public static String hexStringToString(String s) {
        if (s == null || s.equals("")) {
            return null;
        }
        s = s.replace(" ", "");
        byte[] baKeyword = new byte[s.length() / 2];
        for (int i = 0; i < baKeyword.length; i++) {
            try {
                baKeyword[i] = (byte) (0xff & Integer.parseInt(s.substring(i * 2, i * 2 + 2), 16));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        try {
            s = new String(baKeyword, "UTF-8");
            new String();
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        return s;
    }

    //unicode 转字符串
    public static String unicode2String(String unicode) {
        StringBuffer string = new StringBuffer();
        String[] hex = unicode.split("\\\\u");
        for (int i = 1; i < hex.length; i++) {
            // 转换出每一个代码点
            int data = Integer.parseInt(hex[i], 16);
            // 追加成string
            string.append((char) data);
        }
        return string.toString();
    }

    //字符串转换成为16进制(无需Unicode编码)
    public static String str2HexStr(String str) {
        char[] chars = "0123456789ABCDEF".toCharArray();
        StringBuilder sb = new StringBuilder("");
        byte[] bs = str.getBytes();
        int bit;
        for (int i = 0; i < bs.length; i++) {
            bit = (bs[i] & 0x0f0) >> 4;
            sb.append(chars[bit]);
            bit = bs[i] & 0x0f;
            sb.append(chars[bit]);
            // sb.append(' ');
        }
        return sb.toString().trim();
    }

    //16进制直接转换成为字符串(无需Unicode解码)
    public static String hexStr2Str(String hexStr) {
        String str = "0123456789ABCDEF";
        char[] hexs = hexStr.toCharArray();
        byte[] bytes = new byte[hexStr.length() / 2];
        int n;
        for (int i = 0; i < bytes.length; i++) {
            n = str.indexOf(hexs[2 * i]) * 16;
            n += str.indexOf(hexs[2 * i + 1]);
            bytes[i] = (byte) (n & 0xff);
        }
        return new String(bytes);
    }

    /**
     * int/long转16字节字符串(按所占字节数用0补齐)
     *
     * @param byteLen 所占字节长度
     * @param b       需要转换的数字
     * @return str16
     */
    public static String numToStr16(int byteLen, long b) {
        return String.format("%0" + byteLen * 2 + "x", b);
    }

    /**
     * float/double转16字节字符串(按所占字节数用0补齐)
     *
     * @param byteLen 所占字节长度
     * @param b       需要转换的数字
     * @return str16
     */
    public static String numToStr16(int byteLen, double b) {
        byte[] bytes = Hex.getBytes(b);
        int anInt = Hex.getInt(bytes);
        return String.format("%0" + byteLen * 2 + "x", anInt);
    }

    /**
     * 16进制字符串转字符串（ASCII）
     *
     * @param x16 十六进制字符串
     * @return string
     */
    public static String x16toString(String x16) {
        if (x16 == null || "".equals(x16.trim())) {
            return "";
        }
        String tempStr = "";
        byte[] b = new byte[x16.length() / 2];
        for (int i = 0; i < x16.length() / 2; i++) {
            tempStr = x16.substring(i * 2, i * 2 + 2);
            int temp = Integer.parseInt(tempStr, 16);
            b[i] = (byte) temp;
        }
        return new String(b, StandardCharsets.US_ASCII);
    }

    /**
     * 16进制字符串转字符串（GBK）
     *
     * @param x16 十六进制字符串
     * @return string
     */
    public static String x16toGbk(String x16) {
        byte[] bytes = new byte[x16.length() / 2];
        byte tempByte = 0;
        byte tempHigh = 0;
        byte tempLow = 0;
        for (int i = 0, j = 0; i < x16.length(); i += 2, j++) {
            tempByte = (byte) (((int) x16.charAt(i)) & 0xff);
            if (tempByte >= 48 && tempByte <= 57) {
                tempHigh = (byte) ((tempByte - 48) << 4);
            } else if (tempByte >= 97 && tempByte <= 101) {
                tempHigh = (byte) ((tempByte - 97 + 10) << 4);
            }
            tempByte = (byte) (((int) x16.charAt(i + 1)) & 0xff);
            if (tempByte >= 48 && tempByte <= 57) {
                tempLow = (byte) (tempByte - 48);
            } else if (tempByte >= 97 && tempByte <= 101) {
                tempLow = (byte) (tempByte - 97 + 10);
            }
            bytes[j] = (byte) (tempHigh | tempLow);
        }
        String result = null;
        try {
            result = new String(bytes, "GBK");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return result;
    }


    public static boolean isChinese(String s) {
        boolean result = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
            if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
                    || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
                    || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
                    || ub == Character.UnicodeBlock.GENERAL_PUNCTUATION
                    || ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
                    || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS) {
                result = true;
            }
        }
        return result;
    }

    private static String byteArrToHex(byte[] btArr) {
        char[] strArr = new char[btArr.length * 2];
        int i = 0;
        for (byte bt : btArr) {
            strArr[i++] = HEX_CHAR_ARR[bt >>> 4 & 0xf];
            strArr[i++] = HEX_CHAR_ARR[bt & 0xf];
        }
        return new String(strArr);
    }

    private static byte[] hexToByteArr(String hexStr) {
        char[] charArr = hexStr.toCharArray();
        byte[] btArr = new byte[charArr.length / 2];
        int index = 0;
        for (int i = 0; i < charArr.length; i++) {
            int highBit = HEX_STR.indexOf(charArr[i]);
            int lowBit = HEX_STR.indexOf(charArr[++i]);
            btArr[index] = (byte) (highBit << 4 | lowBit);
            index++;
        }
        return btArr;
    }

    /**
     * 字符串转16进制字符串（无汉字utf-8，有汉字gbk）
     *
     * @param str
     * @return
     */
    public static String str2StrHex(String str) {
        boolean chinese = isChinese(str);
        if (chinese) {
            try {
                byte[] bytes1 = str.getBytes(StandardCharsets.UTF_8);
                byte[] bytes2 = new String(bytes1, StandardCharsets.UTF_8).getBytes("gbk");
                String gbk = new String(bytes2, "gbk");
                byte[] gbkArr = gbk.getBytes();
                return byteArrToHex(gbkArr);

            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
                return null;
            }
        } else {
            return strTo16(str);
        }
    }

    /**
     * 16进制字符串转字符串（无汉字utf-8，有汉字gbk）
     *
     * @param strHex
     * @return
     */
    public static String strHex2Str(String strHex) {
        byte[] bytes = hexToByteArr(strHex);
        String s1 = new String(bytes, StandardCharsets.UTF_8);
        boolean chinese = isChinese(s1);
        if (!chinese) {
            try {
                return new String(bytes, "gbk");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
                return null;
            }
        } else {
            return s1;
        }
    }


}