Hex转化工具

C语言快速互转HEX(16进制)和原始字符串/数组 这里如果还用查表的话,这个rom占用会浪费掉不少空间,所以查表法直接就被否决掉了(如果是PC上,追求极致速度的话,当然可以用)。毕竟这代码是要在MCU上面跑的,要同时考虑到时间和空间的最优解。如果这个字符是字母,不论大写小写,只需要看低四位就可以直接判断这个字符代表的数是多少。当然讨论的是有结果的,具体实现的方法和代码在下面展示。同时,在上面的分析也可以发现,这个其实很简单,追求速度的话,查表就好了。如果不是,直接取这个字符的低四位当作结果。如果是,则为字母,将他的低四位加上。HEX串转成数值数组。 阅读详情
package com.jquery.service.android.utils;


import android.util.Log;

import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;


/**
 * 字符串与16进制转换工具
 * @param str
 */

public class HexUtils {
    private static final int[] DEC = new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15};
    private static final byte[] HEX = new byte[]{48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102};
    private static final char[] hex = "0123456789abcdef".toCharArray();
    private static String TAG = "HexUtils";

    public HexUtils() {
    }

    public static int getDec(int index) {
        try {
            return DEC[index - 48];
        } catch (ArrayIndexOutOfBoundsException var2) {
            return -1;
        }
    }

    public static byte getHex(int index) {
        return HEX[index];
    }

    public static String hexString2BinaryString(String hexString) {
        if (hexString == null || hexString.length() % 2 != 0)
            return null;
        String bString = "", tmp;
        for (int i = 0; i < hexString.length(); i++) {
            tmp = "0000" + Integer.toBinaryString(Integer.parseInt(hexString.substring(i, i + 1), 16));
            bString += tmp.substring(tmp.length() - 4);
        }
        return bString;
    }


    public static String binaryString2HexString(String bString) {
        if (bString == null || bString.equals("") || bString.length() % 8 != 0)
            return null;
        StringBuffer tmp = new StringBuffer();
        int iTmp = 0;
        for (int i = 0; i < bString.length(); i += 4) {
            iTmp = 0;
            for (int j = 0; j < 4; j++) {
                iTmp += Integer.parseInt(bString.substring(i + j, i + j + 1)) << (4 - j - 1);
            }
            tmp.append(Integer.toHexString(iTmp));
        }
        return tmp.toString();
    }

    public static String toHexString(byte[] bytes) {
        if (null == bytes) {
            return null;
        } else {
            StringBuilder sb = new StringBuilder(bytes.length << 1);

            for (int i = 0; i < bytes.length; ++i) {
                sb.append(hex[(bytes[i] & 240) >> 4]).append(hex[bytes[i] & 15]);
            }

            return sb.toString();
        }
    }

    public static byte[] fromHexString(String input) {
        if (input == null) {
            return null;
        } else if ((input.length() & 1) == 1) {
            throw new IllegalArgumentException("The input must consist of an even number of hex digits");
        } else {
            char[] inputChars = input.toCharArray();
            byte[] result = new byte[input.length() >> 1];

            for (int i = 0; i < result.length; ++i) {
                int upperNibble = getDec(inputChars[2 * i]);
                int lowerNibble = getDec(inputChars[2 * i + 1]);
                if (upperNibble < 0 || lowerNibble < 0) {
                    throw new IllegalArgumentException("The input must consist only of hex digits");
                }

                result[i] = (byte) ((upperNibble << 4) + lowerNibble);
            }

            return result;
        }
    }

    public static String decodeFromHexString(String hexString) {
        return new String(fromHexString(hexString));
    }

    /**
     * 高低位交换
     *
     * @param data           被交换数据,长度为switchUnitSize的整数倍
     * @param switchUnitSize 交换单元字节数,2的倍数
     * @return
     */
    public static byte[] byteHighLowSwitch(byte[] data, int switchUnitSize) {
        if (data == null || data.length < switchUnitSize
                || (switchUnitSize < 2 && switchUnitSize % 2 != 0)
                || data.length % switchUnitSize != 0)
            return null;
        int switchUnitNum = data.length / switchUnitSize;
        int byteLen = switchUnitSize / 2;
        byte[] result = new byte[data.length];
        for (int i = 0; i < switchUnitNum; i++) {
            for (int j = 0; j < byteLen; j++) {
                result[(i + 1) * switchUnitSize - byteLen * 2 + j] = data[(i + 1) * switchUnitSize - byteLen + j];
                result[(i + 1) * switchUnitSize - byteLen + j] = data[(i + 1) * switchUnitSize - byteLen * 2 + j];
            }
        }
        return result;
    }

    public static byte[] byteReverse(byte[] data) {
        if (data == null) {
            return null;
        }
        byte[] result = new byte[data.length];
        for (int i = 0; i < data.length; i++) {
            result[i] = data[data.length - i - 1];
        }
        return result;
    }

    /**
     * 字节数组转换为ASCII码
     *
     * @param b
     * @return
     */
    public static String byteToAscii(byte[] b) {

        String s = new String(b);

        char[] chars = s.toCharArray(); //把字符中转换为字符数组

        String temp = "";

        for (int i = 0; i < chars.length; i++) {//输出结果

            temp = temp + chars[i];
        }
        try {
            //temp = new String(temp.getBytes("utf-8"), "utf-8");
            String temps = changeCharset(temp, US_ASCII, UTF_8);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return temp;
    }

    public static final String US_ASCII = "US-ASCII";
    /**
     * 8 位 UCS 转换格式
     */
    public static final String UTF_8 = "UTF-8";

    /**
     * 将Ascii转换成中文字符串
     */
    /**
     * 字符串编码转换的实现方法
     *
     * @param str        待转换编码的字符串
     * @param newCharset 目标编码
     * @return
     * @throws UnsupportedEncodingException
     */
    public String changeCharset(String str, String newCharset)
            throws UnsupportedEncodingException {
        if (str != null) {
            //用默认字符编码解码字符串。
            byte[] bs = str.getBytes();
            //用新的字符编码生成字符串
            return new String(bs, newCharset);
        }
        return null;
    }

    /**
     * 字符串编码转换的实现方法
     *
     * @param str        待转换编码的字符串
     * @param oldCharset 原编码
     * @param newCharset 目标编码
     * @return
     * @throws UnsupportedEncodingException
     */
    public static String changeCharset(String str, String oldCharset, String newCharset)
            throws UnsupportedEncodingException {
        if (str != null) {
            //用旧的字符编码解码字符串。解码可能会出现异常。
            byte[] bs = str.getBytes(oldCharset);
            //用新的字符编码生成字符串
            return new String(bs, newCharset);
        }
        return null;
    }


    /**
     * AscII码转换为字节数组
     *
     * @param str
     * @return
     */
    public static byte[] asciiToByte(String str) {
        try {
            byte[] tBytes = str.getBytes("US-ASCII");
            return tBytes;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            return null;
        }
    }

    public static boolean byteArrayCompare(byte[] b1, byte[] b2) {
        if (null == b1 || null == b2) {
            return false;
        } else if (b1.length != b2.length) {
            return false;
        } else {
            for (int i = 0; i < b1.length; i++) {
                if (b1[i] != b2[i]) {
                    return false;
                }
            }
            return true;
        }
    }


    public static String byteArray2HexString(byte[] b, boolean flag) {
        StringBuffer buffer = new StringBuffer();
        int temp = 0;

        for (int i = 0; i < b.length; i++) {
            if (b[i] < 0) {
                temp = 256 + b[i];
            } else {
                temp = b[i];
            }

            String ts = Integer.toHexString(temp);
            if (ts.length() == 1) {
                if (flag) {
                    buffer.append("0" + ts + " ");
                } else {
                    buffer.append("0" + ts);
                }
            } else {
                if (flag) {
                    buffer.append(ts + " ");
                } else {
                    buffer.append(ts);
                }
            }
        }
        return buffer.toString();
    }

    /**
     * 十六进制字符串->字节数组
     *
     * @param hexString
     * @return
     */
    public static byte[] hexStringTobyteArray(String hexString) {
        int length = hexString.length();
        if (length % 2 != 0) {
            hexString = "0" + hexString;
            length = hexString.length();
        }
        byte[] b = new byte[length / 2];

//        BigInteger bigInteger = new BigInteger(hexString, 16);
//        byte[] bytes = toByteArray(bigInteger);
//        Log.e(TAG,"十六进制字符串->字节数组转换:"+bigInteger);
//        bytes=new byte[length / 2];
//        for (int i = 0; i < length / 2; i++) {
//            bytes[i] = (byte) ((int) Integer.valueOf(hexString.substring(2 * i, 2 * i + 2), 16));
//        }

        for (int i = 0; i < length / 2; i++) {
            //  BigInteger bigInteger = new BigInteger(hexString.substring(2 * i, 2 * i + 2), 16);
//            b[i] = (byte) ((BigInteger) bigInteger);
            //   b[i] = (byte) ((BigInteger) bigInteger);
            // b[i] = fromBigInteger(bigInteger,  length / 2);
            b[i] = (byte) ((int) Integer.valueOf(hexString.substring(2 * i, 2 * i + 2), 16));
        }


        return b;
    }



    public static byte[] toByteArray(BigInteger bi) {
        byte[] array = bi.toByteArray();
//        if (array[0] == 0) {
//            byte[] tmp = new byte[array.length - 1];
//            System.arraycopy(array, 1, tmp, 0, tmp.length);
//            array = tmp;
//        }
        byte[] tmp = new byte[array.length - 1];
        System.arraycopy(array, 1, tmp, 0, tmp.length);
        array = tmp;
        return array;
    }

    /**
     * 去掉16进制字符串前面的0X
     *
     * @param hexString
     * @return
     */
    public static String remove0x(String hexString) {
        if (hexString.toUpperCase().startsWith("0X")) {
            hexString = hexString.substring(2);
        }
        return hexString;
    }



    /**
     * IEEE754
     *
     * @param a
     * @return
     */
    public static byte[] floatToBytes(float a) {
        byte[] data = new byte[4];
        if (a == 0) {
            for (int i = 0; i < 4; i++) {
                data[i] = 0x00;
            }
            return data;
        }
        Integer[] intdata = {0, 0, 0, 0};
        a = Math.abs(a);
        // 首先将浮点数转化为二进制浮点数
        float floatpart = a % 1;
        int intpart = (int) (a / 1);

        System.out.println(intpart + " " + floatpart);
        // 将整数部分化为2进制,并转化为string类型
        String intString = "";
        String floatString = "";
        String result = "";
        String subResult = "";
        int zhishu = 0;
        if (intpart == 0) {
            intString += "0";
        }
        while (intpart != 0) {
            intString = intpart % 2 + intString;
            intpart = intpart / 2;
        }
        while (floatpart != 0) {
            floatpart *= 2;
            if (floatpart >= 1) {
                floatString += "1";
                floatpart -= 1;
            } else {
                floatString += "0";
            }

        }

        result = intString + floatString;
        System.out.println(intString + "." + floatString);
        intpart = (int) (a / 1);
        if (intpart > 0) {// 整数部分肯定有1,且以1开头..这样的话,小数点左移
            zhishu = intString.length() - 1;
        } else {// 整数位为0,右移
            for (int i = 0; i < floatString.length(); i++) {
                zhishu--;
                if (floatString.charAt(i) == '1') {
                    break;
                }
            }
            // while(floatString.charAt(index)){}
        }
        // 对指数进行移码操作

        if (zhishu >= 0) {
            subResult = result.substring(intString.length() - zhishu);
        } else {
            subResult = floatString.substring(-zhishu);
        }
        zhishu += 127;
        if (subResult.length() <= 7) {// 若长度

            for (int i = 0; i < 7; i++) {
                if (i < subResult.length()) {
                    intdata[1] = intdata[1] * 2 + subResult.charAt(i) - '0';
                } else {
                    intdata[1] *= 2;
                }

            }

            if (zhishu % 2 == 1) {// 如果质数是奇数,则需要在这个最前面加上一个‘1’
                intdata[1] += 128;
            }
            data[1] = intdata[1].byteValue();
        } else if (subResult.length() <= 15) {// 长度在(7,15)以内
            int i = 0;
            for (i = 0; i < 7; i++) {// 计算0-7位,最后加上第一位
                intdata[1] = intdata[1] * 2 + subResult.charAt(i) - '0';
            }
            if (zhishu % 2 == 1) {// 如果质数是奇数,则需要在这个最前面加上一个‘1’
                intdata[1] += 128;
            }
            data[1] = intdata[1].byteValue();

            for (i = 7; i < 15; i++) {// 计算8-15位
                if (i < subResult.length()) {
                    intdata[2] = intdata[2] * 2 + subResult.charAt(i) - '0';
                } else {
                    intdata[2] *= 2;
                }

            }
            data[2] = intdata[2].byteValue();
        } else {// 长度大于15
            int i = 0;
            for (i = 0; i < 7; i++) {// 计算0-7位,最后加上第一位
                intdata[1] = intdata[1] * 2 + subResult.charAt(i) - '0';
            }
            if (zhishu % 2 == 1) {// 如果质数是奇数,则需要在这个最前面加上一个‘1’
                intdata[1] += 128;
            }
            data[1] = intdata[1].byteValue();

            for (i = 7; i < 15; i++) {// 计算8-15位
                intdata[2] = intdata[2] * 2 + subResult.charAt(i) - '0';
            }
            data[2] = intdata[2].byteValue();

            for (i = 15; i < 23; i++) {// 计算8-15位
                if (i < subResult.length()) {
                    intdata[3] = intdata[3] * 2 + subResult.charAt(i) - '0';
                } else {
                    intdata[3] *= 2;
                }

            }
            data[3] = intdata[3].byteValue();
        }

        intdata[0] = zhishu / 2;
        if (a < 0) {
            intdata[0] += 128;
        }
        data[0] = intdata[0].byteValue();
        byte[] data2 = new byte[4];// 将数据转移,目的是倒换顺序
        for (int i = 0; i < 4; i++) {
            data2[i] = data[3 - i];
        }
        return data2;
    }

 /*   public static String ipV4(byte[] b) {
        String ip = "";
        for (int i = 0; i < b.length; i++) {
            int temp = 0;
            if (b[i] < 0)
                temp = 256 + b[i];
            else
                temp = b[i];
            ip = ip + temp + ".";
        }
        if (StringUtils.isNotBlank(ip)) {
            ip = ip.substring(0, ip.length() - 1);
        }
        return ip;
    }*/

    /**
     * Short Int转byte[]
     *
     * @param s
     * @return
     */
    public static byte[] shortToByteArray(short s) {
        byte[] shortBuf = new byte[2];
        for (int i = 0; i < 2; i++) {
            int offset = (shortBuf.length - 1 - i) * 8;
            shortBuf[i] = (byte) ((s >>> offset) & 0xFF);
        }
        return shortBuf;
    }

    /**
     * byte[]转Short Int
     *
     * @param b
     * @return
     */
    public static int byteArrayToShort(byte[] b) {
        return (b[0] << 8)
                + (b[1] & 0xFF);
    }

    /**
     * Object转double
     *
     * @param sma
     * @return
     */
    public static double objToDouble(Object sma) {
        double amount = 0.0;
        if (sma instanceof Integer) {
            amount = (Integer) sma / 1.0;
        } else if (sma instanceof String) {
            amount = Double.parseDouble((String) sma);
        } else {
            amount = (double) sma;
        }
        return amount;
    }

    /**
     * int转byte[]
     *
     * @param n
     * @return
     */
    public static byte[] intToBytes2(int n) {
        byte[] b = new byte[4];

        for (int i = 0; i < 4; i++) {
            b[i] = (byte) (n >> (24 - i * 8));

        }
        return b;
    }

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

    /**
     * int 转 hex ,高位在前
     *
     * @param inn int
     * @return hex
     */
    public static String IntToHexReversed(int inn) {
        return toHexString(byteReverse(intToBytes2(inn)));

    }

    /**
     * int 转 hex ,高位在前
     *
     * @param inn int
     * @return hex
     */
    public static String intToHex(int inn) {
        return toHexString(intToBytes2(inn));

    }

    /**
     * short 转 hex ,高位在前
     *
     * @param inn int
     * @return hex
     */
    public static String shortToHex(short inn) {
        return toHexString(shortToByteArray(inn));

    }

    /**
     * int 转 hex ,高位在前
     *
     * @param hex hex
     * @return ascii2 string
     */
    public static String hexString2Ascii(String hex) {

        return byteToAscii(hexStringTobyteArray(hex));
    }

    /**
     * ascii 转 hex ,高位在前
     *
     * @param asciiStr String
     * @return hex string
     */
    public static String asciiToHex(String asciiStr) {
        char[] chars = asciiStr.toCharArray();
        StringBuilder hex = new StringBuilder();
        for (char ch : chars) {
            hex.append(Integer.toHexString((int) ch));
        }
        return hex.toString();
    }


    /**
     * 将BCD码转成String
     *
     * @param b byte []
     * @return
     */
    public static String bcdToString(byte[] b) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < b.length; i++) {
            int h = ((b[i] & 0xff) >> 4) + 48;
            sb.append((char) h);
            int l = (b[i] & 0x0f) + 48;
            sb.append((char) l);
        }

        return sb.toString();
    }


    /**
     * @功能: BCD码转为10进制串(阿拉伯数据)
     * @参数: BCD码
     * @结果: 10进制串
     */
    public static String bcd2Str(byte[] bytes) {
        StringBuffer temp = new StringBuffer(bytes.length * 2);
        for (int i = 0; i < bytes.length; i++) {
            temp.append((byte) ((bytes[i] & 0xf0) >>> 4));
            temp.append((byte) (bytes[i] & 0x0f));
        }
        return temp.toString().substring(0, 1).equalsIgnoreCase("0") ? temp
                .toString().substring(1) : temp.toString();
    }

    public static short BcdToHex(short data) {
        short temp;

        temp = (short) ((data >> 4) * 10 + (data & 0x0f));
        return temp;
    }



    /**
     * 字符串转换为16进制字符串
     *
     * @param s
     * @return
     */
    public static String stringToHexString(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进制字符串转换为字符串
     *
     * @param s
     * @return
     */
    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, "gbk");
            new String();
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        return s;
    }

    public static String rev(String ox) {
        String s = ox.substring(2);
        byte b[] = s.getBytes();
        byte result[] = new byte[b.length];
        for (int i = b.length - 1, j = 0; i >= 0; i--, j++)
            result[j] = b[i];
        return new String(result);
    }

    /**
     * 10进制转16进制高位在前地位在后
     *
     * @param var0
     * @return
     */
    public static String lowHigh(int var0) {
        int var1 = 1;
        int var2 = var0 >> 8;
        int var3 = var0 & 255;
        String var4 = Integer.toHexString(var2);
        String var5 = Integer.toHexString(var3);
        if (var4.length() > 2) {
            do {
                if (var1 > 1) {
                    var2 >>= 8;
                }
                var4 = Integer.toHexString(var2 >> 8);
                var5 = var5 + Integer.toHexString(var2 & 255);
                ++var1;
            } while (var4.length() > 2);
        }
        if (var4.length() < 2) {
            var4 = "0" + var4;
        }
        if (var5.length() < 2) {
            var5 = "0" + var5;
        }
        return var5 + var4;
    }


    /**
     * 10进制的数转换为16进制字节,并高位在前,低位在后
     *
     * @param dec
     * @return
     */
    public static String decToHex(int dec) {
        String hex = "";
        while (dec != 0) {
            String h = Integer.toString(dec & 0xff, 16);
            if ((h.length() & 0x01) == 1) {
                h = '0' + h;
            }
            hex = hex + h;
            dec = dec >> 8;
        }
        return hex;
    }

    /**
     * 10进制的数转换为16进制字节,并高位在前,低位在后
     *
     * @param dec
     * @return
     */
    public static String decLongToHex(long dec) {
        String hex = "";
        while (dec != 0) {
            String h = Long.toString(dec & 0xff, 16);
            if ((h.length() & 0x01) == 1) {
                h = '0' + h;
            }
            hex = hex + h;
            dec = dec >> 8;
        }
        return hex;
    }

    public void test(String ox) {

        String temp = "94 01 00 00 60 10";
        List<String> list = Arrays.asList(ox.split(""));
        Collections.reverse(list);

        StringBuffer stringBuffer = new StringBuffer();
        for (String string : list) {
            stringBuffer.append(string);
            stringBuffer.append(" ");
        }
        temp = stringBuffer.toString();
        System.out.println(temp);//10 60 00 00 01 94

    }

    /**
     * 十六进制字符串转换成字符串
     *
     * @param hexStr
     * @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);
    }

    /**
     * 16进制转 字符串 低字节在前,高字节在后
     *
     * @param str
     * @return
     */
    public static String reverse(String str) {
        int length = str.length();
        if ((length & 1) == 1) {
            str = "0" + str;
            length = str.length();
        }
        String string = "";
        for (int i = length / 2 - 1; i >= 0; i--) {
            string += str.substring(2 * i, 2 * i + 2);
        }
        return string;
    }


    /**
     * long 转 hex ,高位在前
     *
     * @param inn int
     * @return hex
     */
    public static String LongToHexReversed(Long inn) {
        return toHexString(byteReverse(longToBytes2(inn)));

    }


    /**
     * long 转 hex ,高位在前
     *
     * @param inn int
     * @return hex
     */
    public static String longToHex(Long inn) {
        return toHexString(longToBytes2(inn));

    }

    /**
     * long转byte[]
     *
     * @param n
     * @return
     */
    public static byte[] longToBytes2(Long n) {
        byte[] b = new byte[4];

        for (int i = 0; i < 4; i++) {
            b[i] = (byte) (n >> (24 - i * 8));

        }
        return b;
    }

    /**
     * 十六进制字符串->字节数组
     *
     * @param hexString
     * @return
     */
    public static byte[] hexString2byteArray(String hexString) {
        int length = hexString.length();

        byte[] b = new byte[length / 2];

        for (int i = 0; i < length / 2; i++) {
            b[i] = (byte) ((int) Integer.valueOf(hexString.substring(2 * i,
                    2 * i + 2), 16));
        }

        return b;
    }

    /**
     * 16进制转10进制
     *
     * @param bytes
     * @return
     */
    public static String bytes2hex03(byte[] bytes) {
        final String HEX = "0123456789abcdef";
        StringBuilder sb = new StringBuilder(bytes.length * 2);
        for (byte b : bytes) {
            sb.append(HEX.charAt((b >> 4) & 0x0f));
            sb.append(HEX.charAt(b & 0x0f));
        }

        return sb.toString();
    }


    /**
     * 10进制转16进制
     *
     * @param num
     * @param totalLenght 需要的字符串总长度
     * @return
     */
    public String toHex(int num, int totalLenght) {
        String str = Integer.toHexString(num);
        str = splicingZero(str, totalLenght);
        return str;
    }

    public static String toHex(long num, int totalLenght) {
        String str = Long.toHexString(num);
        str = splicingZero(str, totalLenght);
        return str;
    }

    /**
     * 字符串前面补零操作
     *
     * @param str         字符串本体
     * @param totalLenght 需要的字符串总长度
     * @return
     */
    public static String splicingZero(String str, int totalLenght) {
        int strLenght = str.length();
        String strReturn = str;
        for (int i = 0; i < totalLenght - strLenght; i++) {
            strReturn = "0" + strReturn;
        }
        return strReturn;
    }


    /**
     * byte[]转十六进制
     *
     * @param bytes
     * @return
     */
    public String bytesTohex(byte[] bytes) {
        StringBuilder hex = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            byte b = bytes[i];
            boolean flag = false;
            if (b < 0) {
                flag = true;
            }
            int absB = Math.abs(b);
            if (flag) {
                absB = absB | 0x80;
            }
            System.out.println(absB & 0xFF);
            String tmp = Integer.toHexString(absB & 0xFF);
            if (tmp.length() == 1) { //转化的十六进制不足两位,需要补0
                hex.append("0");
            }
            hex.append(tmp.toLowerCase());
        }
        return hex.toString();
    }

    /**
     * 十六进制转byte[]
     *
     * @param hex
     * @return
     */
    public static byte[] hexTobytes(String hex) {
        byte[] bytes = new byte[hex.length() / 2];
        for (int i = 0; i < hex.length(); i = i + 2) {
            String subStr = hex.substring(i, i + 2);
            boolean flag = false;
            int intH = Integer.parseInt(subStr, 16);
            if (intH > 127) {
                flag = true;
            }
            if (intH == 128) {
                intH = -128;
            } else if (flag) {
                intH = 0 - (intH & 0x7F);
            }
            byte b = (byte) intH;
            bytes[i / 2] = b;
        }
        return bytes;
    }

    //10进制转16进制
    public static String IntToHex(long n) {
        char[] ch = new char[20];
        int nIndex = 0;
        while (true) {
            long m = n / 16;
            long k = n % 16;
            if (k == 15) {
                ch[nIndex] = 'f';
            } else if (k == 14) {
                ch[nIndex] = 'e';
            } else if (k == 13) {
                ch[nIndex] = 'd';
            } else if (k == 12) {
                ch[nIndex] = 'c';
            } else if (k == 11) {
                ch[nIndex] = 'b';
            } else if (k == 10) {
                ch[nIndex] = 'a';
            } else {
                ch[nIndex] = (char) ('0' + k);
            }
            nIndex++;
            if (m == 0) {
                break;
            }
            n = m;
        }
        StringBuffer sb = new StringBuffer();
        sb.append(ch, 0, nIndex);
        sb.reverse();
        String strHex = new String("0x");
        strHex += sb.toString();
        return strHex;
    }

    //16进制转10进制
    public static Long HexToInt(String strHex) {
        long nResult = 0;
        if (!IsHex(strHex)) {
            return nResult;
        }
        String str = strHex.toUpperCase();
        if (str.length() > 2) {
            if (str.charAt(0) == '0' && str.charAt(1) == 'X') {
                str = str.substring(2);
            }
        }
        int nLen = str.length();
        for (int i = 0; i < nLen; ++i) {
            char ch = str.charAt(nLen - i - 1);
            try {
                nResult += (GetHex(ch) * GetPower(16, i));
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return nResult;
    }

    //计算16进制对应的数值
    public static int GetHex(char ch) throws Exception {
        if (ch >= '0' && ch <= '9') {
            return (int) (ch - '0');
        }
        if (ch >= 'a' && ch <= 'f') {
            return (int) (ch - 'a' + 10);
        }
        if (ch >= 'A' && ch <= 'F') {
            return (int) (ch - 'A' + 10);
        }
        throw new Exception("error param");
    }

    //计算幂
    public static long GetPower(long nValue, long nCount) throws Exception {
        if (nCount < 0) {
            throw new Exception("nCount can't small than 1!");
        }
        if (nCount == 0) {
            return 1;
        }
        long nSum = 1;
        for (long i = 0; i < nCount; ++i) {
            nSum = nSum * nValue;
        }
        return nSum;
    }

    //判断是否是16进制数
    public static boolean IsHex(String strHex) {
        int i = 0;
        if (strHex.length() > 2) {
            if (strHex.charAt(0) == '0' && (strHex.charAt(1) == 'X' || strHex.charAt(1) == 'x')) {
                i = 2;
            }
        }
        for (; i < strHex.length(); ++i) {
            char ch = strHex.charAt(i);
            if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f')) {
                continue;
            }
            return false;
        }
        return true;
    }

    /**
     *      * 十六进制字符串校验(不够4个长度补齐0)
     *      * @param lockAddress
     *      * @return
     *      
     */
    public static String checkValidityHex(String hex, int hexLengh) {

        StringBuffer s1 = new StringBuffer(hex);
        int index;
        for (index = 2; index < s1.length(); index += 3) {
            s1.insert(index, ',');
        }
        String[] array = s1.toString().split(",");
        String[] swapOrder = (array);
        StringBuffer s2 = new StringBuffer();
        for (String str : swapOrder) {
            s2.append(str);
        }
        String s3 = s2.toString();
        if (s3.length() != 4 || s3.length() != 8) {
            int count = (hexLengh - s3.length());
            for (int i = 0; i < count; i++) {
                s3 = "0" + s3;
            }
        }
        return s3;

    }

    public int hexToIntArraged(String workVolumeDose) {
        byte[] workVolumeArray = hexStringTobyteArray(workVolumeDose);
        return byteToInt2(byteReverse(workVolumeArray));
    }

//    public int hexToIntArraged( String data) {
//        byte[] byteDataArray = HexUtils.hexStringTobyteArray(data);
//        return HexUtils.byteToInt2(byteReverse(byteDataArray));
//    }


    /**
     * 16进制高低位转换(低位在前高位在后) reverseHighToLowHex
     *
     * @param hex
     * @return
     */

    public static String reverseHighToLowHex(final String hex) {
        final char[] charArray = hex.toCharArray();
        final int length = charArray.length;
        final int times = length / 2;
        for (int c1i = 0; c1i < times; c1i += 2) {
            final int c2i = c1i + 1;
            final char c1 = charArray[c1i];
            final char c2 = charArray[c2i];
            final int c3i = length - c1i - 2;
            final int c4i = length - c1i - 1;
            charArray[c1i] = charArray[c3i];
            charArray[c2i] = charArray[c4i];
            charArray[c3i] = c1;
            charArray[c4i] = c2;
        }
        return new String(charArray);
    }

    /**
     * 16进制高低位转换(高位在前低位在后) reverseLowToHighHex
     *
     * @param hex
     * @return
     */
    public static String reverseLowToHighHex(final String hex) {
        final char[] charArray = hex.toCharArray();
        final int length = charArray.length;
        final int times = length / 2;
        for (int c1i = 0; c1i < times; c1i += 2) {
            final int c2i = c1i + 1;
            final char c1 = charArray[c1i];
            final char c2 = charArray[c2i];
            final int c3i = length - c1i - 2;
            final int c4i = length - c1i - 1;
//            charArray[c1i] = charArray[c3i];
//            charArray[c2i] = charArray[c4i];
//            charArray[c3i] = c2;
//            charArray[c4i] = c1;


            charArray[c4i] = charArray[c3i];
            charArray[c3i] = charArray[c4i];
            charArray[c2i] = c1;
            charArray[c1i] = c2;
        }
        return new String(charArray);
    }

    public static String lowHigh2(int var0) {
        int var1 = 1;
        int var2 = var0 >> 8;
        int var3 = var0 & 255;
        String var4 = Integer.toHexString(var2);
        String var5 = Integer.toHexString(var3);
        if (var4.length() > 2) {
            do {
                if (var1 > 1) {
                    var2 >>= 8;
                }
                var4 = Integer.toHexString(var2 >> 8);
                var5 = var5 + Integer.toHexString(var2 & 255);
                ++var1;
            } while (var4.length() > 2);
        }
        if (var4.length() < 2) {
            var4 = "0" + var4;
        }
        if (var5.length() < 2) {
            var5 = "0" + var5;
        }
        return var5 + var4;
    }

    /**
     * 数字参数返回(4字节、8字节都适用)
     *
     * @param hex
     * @return
     */
    public static int getHexDataToInt(String hex) {
        int digit = -1;
        int a;
        BigInteger bi;
        int length = hex.length();
        if (length == 4) {
            String str = hex.substring(2, 3);
            BigInteger data = new BigInteger(str, 16);
            digit = data.intValue();
        }

        String reverseLowToHighHex = reverseHighToLowHex(hex);
        if (length == 4 && digit >= 8) {
            //16进制转10进制
            bi = new BigInteger("ffff" + reverseLowToHighHex, 16);
        } else {
            //16进制转10进制
            bi = new BigInteger(reverseLowToHighHex, 16);
        }
        a = bi.intValue();
        return a;
    }

    /**
     * 设置数字参数
     *
     * @param num           数字
     * @param lenght        hex 长度  4或是8
     * @param magnification 放大倍数
     * @return
     */
    public static String setHexData(int num, int lenght, int magnification) {

        BigDecimal result = (new BigDecimal(num));
        BigDecimal results = result.multiply(BigDecimal.valueOf(magnification));
        Log.e(TAG, "setHexData results !=   " + results);

        //10进制转16进制
        String hex2 = Integer.toHexString((results.intValue()));
        Log.e(TAG, "setHexData hex2 !=   " + hex2);

        String checkValidityHex = checkValidityHex(hex2, lenght);
        Log.e(TAG, "setHexData checkValidityHex !=   " + checkValidityHex);
        if (checkValidityHex.length() > lenght) {
            checkValidityHex = checkValidityHex.substring(lenght);
        }
        String reverseHighToLowHex = reverseHighToLowHex(checkValidityHex);

        Log.e(TAG, "setHexData reverseHighToLowHex !=   " + reverseHighToLowHex);

        String data = "";
        if (lenght == 8) {
            int len = 8 - reverseHighToLowHex.length();
            for (int i = 0; i < len; i++) {
                reverseHighToLowHex += "0";
            }
        }
        return reverseHighToLowHex;
    }

    /**
     * 整数Hex设置
     *
     * @param portResult
     * @param magnification
     * @return
     */

    public static String setHexDataResult(String portResult, int magnification) {
        String data = "";
        data = HexUtils.decToHex(Integer.parseInt(portResult) * magnification);
        int len = 8 - portResult.length();
        for (int i = 0; i < len; i++) {
            data += "0";
        }
        return data;
    }

    /**
     * 强制转化成BigDecimal保证精度
     *
     * @param num           数字字符串
     * @param magnification 1*100的倍数
     * @return
     */

    public static BigDecimal setBigDecimal(String num, int magnification) {
        BigDecimal result = (new BigDecimal(num));
        Log.e(TAG, "results setBigDecimal !=   " + result);
        BigDecimal results = result.multiply(BigDecimal.valueOf(magnification));
        return results;
    }

}
C# Hex工具类(可用于mac转化) 主要用于string 与 bytes的十六进制互转 using System; using System.Text; public static class HexUtils{ /// <summary> /// 字符串hex转bytes 可处理Mac /// </summary> /// <param name="str">字符串</param> /// <para. 阅读详情

相关推荐

HEX文件与机器语言:嵌入式固件的底层执行原理

HEX文件是嵌入式系统中程序代码的标准化文本化二进制载体,本质为Intel HEX格式,用于在资源受限环境下可靠传递可执行数据;机器语言则是CPU唯一可直接执行的指令序列,由操作码与操作数组成,严格对应硬件微架构。二者共同构成从高级代码到物理执行的关键转换层,支撑固件烧录、调试验证与逆向分析等核心工程活动。理解HEX记录结构(地址/类型/校验)和机器码语义(如8051的MOV、AJMP指令),是定位启动失败、内存越界、时序异常等问题的技术基础。本文深入解析HEX与机器语言的协同机制,覆盖地址映射、校验逻辑、

weixin_35751412的博客 573

字符串、HEX 十六进制互转工具

最近,在搞BLE相关的项目,需要用到字符串转16进制通过广播包发送出去,但是在网上找了好久都没有找到相应要的工具,终于在我坚持不懈的寻找下,发现了这款免费的转换工具!有需要的自取,使用起来也很方便!我就不一 一列举啦,有兴趣的去首页发掘吧!在网站首页 还有很多实用的工具!

嵌入式菜鸟,练习时长一坤年。 2388

纸飞机串口调试助手:自定义HEX协议与串口调试实战

串口通信是嵌入式开发中最基础的调试手段,而以HEX(十六进制)表示的字节流则是设备间交换指令的通用语言。理解HEX发送与显示的差异、帧结构组成以及校验算法,是高效调试的前提。在实际工程中,面对MODBUS RTU、YMODEM乃至SPI等协议,开发者常需处理HEX转字符串、计算校验码、解析每两位HEX字符等重复性工作。支持自定义HEX协议的串口调试助手,将报文模板、自动校验、定时发送与日志记录整合为标准化流程,从而降低人工拼包出错率,提升联调效率。纸飞机串口调试助手正是此类工具的代表,通过配置协议模板即可快

weixin_31534091的博客 299

功能强大的 HEX 开源转换工具,你值得拥有

来源:公众号【鱼鹰谈单片机】作者:鱼鹰OspreyID :emOsprey功能你是否存在这样的需求?将 HEX 转化为 BIN文件?将 BIN 文件转化为 HEX 文件?将两个 HEX...

EmbeddedOsprey 4251

字符串转hex小工具

字符串转hex小工具分享

汽车电子软件领域知识分享 1791

64位Win7专用hex2bin格式转换工具

程序允许用户通过命令行参数或图形界面设置输出路径。在代码中,通过strdup函数保存用户输入路径,并在写入Bin文件时使用fopen函数指定完整路径。if(!return -1;if(!fclose(fp);return 0;参数说明:path:用户指定的输出路径。:已填充的数据缓冲区。:有效数据长度。此实现方式确保用户可以灵活指定输出位置,提升程序的可用性。

weixin_32252929的博客 465

深入理解Hex、Bin区别,转化、合并内部机理,及工具使用!

深入理解Hex、Bin区别,转化、合并内部机理,及工具使用。

qq_40446979的博客 1929

Ascii Unicode Hex转码工具

Ascii Unicode Hex转码工具,可以将数据从3种编码相互转换

【亲测免费】 HEX文件转化工具 - HEX2Txt

HEX文件转化工具 - HEX2Txt 【下载地址】HEX文件转化工具-HEX2Txt HEX文件转化工具是一款基于C#语言开发的实用工具,专为将HEX文件转换为TXT文件而设计。通过简单的操作,用户可以将HEX文件中的数据提取并逐行显示在TXT文件中,支持1byte、2byte和4byte三种转换方式。工具界面简洁易用...

gitblog_06726的博客 627

6.4 构网型储能的需求与配置

摘要: 构网型储能是新型电力系统的关键支撑技术,通过提供电压/频率形成、惯性和稳定控制能力,解决同步机退出导致的系统稳定性问题。其配置需遵循三大原则:1)容量配置以支撑需求为主导,兼顾能量服务;2)优先布局于电网薄弱点、稳定问题突出区域;3)采用自适应控制策略实现全工况优化。核心应用场景包括新能源送出通道稳定、负荷中心调频、黑启动电源等。规划方法需结合系统分析、量化指标和成本效益评估,实现技术经济最优。未来需重点关注构网/跟网混合系统的临界容量占比及自适应控制技术发展。

技术工作者 1143

STM32CubeIDE入坑指南

一 前言 在科技日新月异的今天,作为从事效率为先的苦逼 IT 行业,秉承着我不入地狱谁入地狱的伟大革命精神,我决定再一次做第一个吃螃蟹的人,通过自身的入坑过程,为大家测试STM32CubeIDE这款新式工具。(其实是为了我能省点时间,快点做完项目,多挣点钱买几瓶肾气丸) 二 看一看别人是如何入坑的 二 手把手带你入坑 三 相关资料 ...

CH的博客 1万+

HEX文件转化工具-HEX2Txt:轻松实现数据转换

HEX文件转化工具-HEX2Txt:轻松实现数据转换 【下载地址】HEX文件转化工具-HEX2Txt HEX文件转化工具是一款基于C#语言开发的实用工具,专为将HEX文件转换为TXT文件而设计。通过简单的操作,用户可以将HEX文件中的数据提取并逐行显示在TXT文件中,支持1byte、2byte和4byte三种转换方式。工...

gitblog_06712的博客 599

手把手教你用树莓派蓝牙抓取小米温湿度计2代数据,接入HomeAssistant(附密钥获取避坑指南)

本文详细介绍了如何通过树莓派蓝牙抓取小米温湿度计2代数据并接入HomeAssistant的完整流程。重点解析了获取32位加密密钥的三种方法,包括使用Telink Flasher工具、米家APP抓包和开源工具ATC_MiThermometer,并提供了HomeAssistant集成配置和常见问题排查指南,帮助用户实现稳定可靠的温湿度监测。

一名菜鸟攻城师 780

linux下hex文件到bin文件的格式转化,hex转换成bin文件小工具(HEX2BIN.EXE)下载_hex转换成bin文件小工具(HEX2BIN.EXE)官方下载-太平洋下载中心...

HEX 转 BIN 程序,弄过单片机的人可能都知道,很多编译器都会编译出一种叫HEX 的文件,这好像是Intel定的一个格式,就是把二进制的机器代码文件以16进制的字符形式(文本)保存,写进cpu或rom前都需要进行转化,此小程序便可完成该任务了。该工具将Intel HEX文件转换成binary二进制文件,你可以在大多数EPROM编程器中使用BIN文件,也可以容易的用他们来CRC或者校验计算(ch...

weixin_34611277的博客 982

YOLOv8验证的命令以及计算coco指标

好久不看代码,都不知道怎么验证的了,来记录一下。1、计算coco指标。

毕竟是Shy哥 1481

STM32HAL库学习笔记九——LCD显示

本文不会对驱动编写做特别详细的描述,以记录CubeMX的部署流程为主。

weixin_44762233的博客 6920

BIN文件和HEX文件互转合并

因需要使用阿莫脱机下载器制作STM32脱机下载文件,而配置文件部分只有bin格式的,整合不了,所以需要把bin文件转化为hex文件。源代码很简单,不介绍了,直接上对话框图和代码,需要者自取。的代码,写了个对话框的程序。共享出来,给有需要的人。

hyhsandy1803的博客 7100

使用 ChatGPT/Copilot 提升前端开发效率的 N 种方式

typescript// 输入:根据这个 JavaScript 对象,生成完整的 TypeScript 类型定义id: '123',stock: 50,},// ChatGPT 生成:id: string;discount?: number;// 可选属性// 只读属性// 更进一步,生成 Zod schema 用于运行时验证:});}),});AI 代码助手真正的革命性不在于它能生成多少代码,而在于它改变了我们解决问题的方式。

fineday 1595

将二进制转为Verilog可识别的hex文件(十六进制)

我们拿到可执行的程序大部分是二进制的,如何在verilog中运行? 首先注意:Verilog中使用的Hex与intelhex格式不同! 转化过程: (1)首先将二进制用工具bin2mif.c转化成verilog的Hex文件,当然先用gcc编译bin2mif.c,然后运行改程序就行,程序源码在文档后面附上。 (2)然后注意:转化的十六进制文件是否是你的verilog需要的对齐格式,有

Heron——Linux & ARM 6994

分析方法—temporal receptive field(TRF)

总结来说,时间感受野其实就是一个 filter!课程中的描述—.(使用时间感受野与刺激进行卷积来描述)时间感受野一般是听觉计算中使用的,在视觉中,有另一种分析叫做空间感受野(spatial receptive fields)。回归权重(Regression weights)是指在回归分析中用于估计自变量与因变量之间关系的权重或系数。回归分析是一种统计方法,用于建立自变量与因变量之间的关联模型,并通过拟合数据来估计模型中的参数。在简单线性回归中,只有一个自变量与一个因变量之间的关系被建模。

m0_51474171的博客 1606

Transformer-LSTM预测 | 基于Transformer-LSTM的多变量单步时间序列预测(Matlab)

Transformer-LSTM预测 | 基于Transformer-LSTM的多变量单步时间序列预测(Matlab)

机器学习之心的博客,关注并私信文章链接,获取对应文章源码和数据。 192

利用Keil C将“.hex”文件转".iic"文件(转帖)

固件调试完毕后,可以将其转化为IIC文件烧写到EEPROM中,采用C2方式启动,这样68013就会从EEPROM中获取程序和VID、PID,不需要每次上电都下载固件了。 首先需要将KEIL编译好的hex文件转化为iic文件,可以使用cypress提供的hex2bix, 在Keil C软件中,选择Project—>Options for Target 'Targer 1',选择Outpu

znmdwahaha的专栏 4180

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

发现hex

今天发现了 网易有道推出的将web做成桌面客户端的开源工具hex http://hex.youdao.com/zh-cn/index.html 只看到支持windows和 macosx,是否能在linux下开发呢 转载于:https://www.cnblogs.com/toyor/p/5465101.html...

weixin_30347335的博客 72

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

揭秘AnotherRedisDesktopManager的Hex查看器:让二进制数据无所遁形

在Redis日常管理中,你是否遇到过这些令人头疼的场景:面对乱码的二进制数据束手无策?尝试修改特殊格式的值却担心破坏数据结构?想要分析序列化内容却缺乏直观工具?AnotherRedisDesktopManager的Hex查看器(十六进制查看器)正是为解决这些问题而生。本文将带你深入了解这个强大工具的工作原理和实用技巧,让你轻松驾驭各种复杂数据格式。 ## Hex查看器的核心价值 Hex查看器(...

gitblog_00345的博客 486

microbit python编译器_一款命令行工具把玩 micro:bit

闲暇做回小搬运,搬运个小工具的使用教程。micro: bit 是一款由英国 BBC 设计的 ARM 架构的单片机,板载蓝牙,加速度计,电子罗盘,三个按钮,5 x 5 LED 点阵,主要用于青少年的编程教育。micro: bit 正面图.png它支持我们编写 Python 代码,并将程序 烧录 进去然后实现一些我们想要的效果。写 Python 代码自然是在个人电脑的代码编辑器中完成,烧录代码则通过一...

weixin_34803738的博客 1844

将TI DSP的.out文件转换成数据流形式的二进制bin文件的方法

最近在做的串口升级程序,需要将.out文件转换成二进制文件烧写到flash中脱机使用。      转化方法分为两步:     (1)先将.out文件转换为hex文件:      这里的方法提供参考:      a.先写一个cmd配置文件,以SCI—A启动模式为例,文件名xxx.c

ghjk014的专栏 7004
上一篇: Unable to load class 'org.jetbrains.kotlin.kapt3.base.Kapt'. Possible causes for this unexpected err
下一篇: Gradle sync failed: Minimum supported Gradle version is 4.10.1. Current version is 4.6. If using the
J-query
博客等级 码龄10年 248粉丝 39原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值