package com.mh.common.utils;

import com.alibaba.fastjson2.JSONObject;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import org.apache.commons.codec.binary.Hex;

import java.io.*;
import java.math.BigInteger;
import java.net.SocketTimeoutException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static com.mh.common.utils.sign.Base64.encode;

/**
 * @Auther: LJF
 * @Date: 2020-02-26 15:11
 * @Description:
 */
public class ExchangeStringUtil {

    public static void main(String args[]) {

//       int ieee754Int = Integer.parseInt(str, 16);
//       float realValue = Float.intBitsToFloat(ieee754Int);
//       System.out.println(realValue);
//
//        SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        Date date=new Date();
//        String curDate=sdf1.format(date);
//        System.out.println(curDate);
//        String m=curDate.substring(0,15)+"0";
//        System.out.println(m);
//        try{
//            getTodayWeather1("广州");
//        }catch (Exception e){
//
//        }

//        String str=ExchangeStringUtil.dateRoll(1,"");
//        System.out.println("当前时间前1小时"+str);
//        str=ExchangeStringUtil.dateRoll(2,"");
//        System.out.println("当前时间前2小时"+str);
//        str=ExchangeStringUtil.dateTime(5);
//        System.out.println("当前时间前5分钟"+str);
//        str=ExchangeStringUtil.dateTime(15);
//        System.out.println("当前时间前15分钟"+str);
//        str=ExchangeStringUtil.dateTime(30);
//        System.out.println("当前时间前30分钟"+str);
        System.out.println("--------------------------------------------------");
    }

    /**
     * 获取到对应的buffer
     *
     * @param ctx
     * @param sendStr
     * @return
     */
    public static ByteBuf getByteBuf(ChannelHandlerContext ctx, String sendStr) {
        // byte类型的数据
//        byte[] bytes = "这里是将要写往服务端的数据".getBytes(Charset.forName("utf-8"));
//        String sendStr = "5803004900021914";          // 冷量计
        // 申请一个数据结构存储信息
        ByteBuf buffer = ctx.alloc().buffer();
        // 将信息放入数据结构中
        buffer.writeBytes(ExchangeStringUtil.hexStrToBinaryStr(sendStr));//对接需要16进制
        return buffer;
    }

    /**
     * double转换为String ：当为整数时，只显示整数，当小数时直接显示小数
     *
     * @param num
     * @return
     */
    public static String doubleTrans1(double num) {
        if (num % 1.0 == 0) {
            return String.valueOf((long) num);
        }
        return String.valueOf(num);
    }

    /**
     * 获取String中的数值
     *
     * @param result
     * @return
     */
    public static String getNumFromString(String result) {
        String regEx = "[^0-9]";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(result);
        return m.replaceAll("").trim();
    }

    /**
     * 获取检验位值，update by ljf on 2020-06-02
     *
     * @param result
     * @return
     */
    //返回指令+校验码
    public static String getCRCStr(String result) {
        byte[] strOrder = ExchangeStringUtil.hexStrToBinaryStr(result);
        int checkNum = CRC16.CRC16_MODBUS(strOrder);
        String checkWord = ExchangeStringUtil.decToHex(String.valueOf(checkNum));
        checkWord = ExchangeStringUtil.addZeroForNum(checkWord, 4);
        checkWord = checkWord.substring(2, 4) + checkWord.substring(0, 2);
        result = result + checkWord;
        return result;
    }

    //只返回校验码
    public static String getStrCRC16(String result) {
        byte[] strOrder = ExchangeStringUtil.hexStrToBinaryStr(result);
        int checkNum = CRC16.CRC16_MODBUS(strOrder);
        String checkWord = ExchangeStringUtil.decToHex(String.valueOf(checkNum));
        checkWord = ExchangeStringUtil.addZeroForNum(checkWord, 4);
        checkWord = checkWord.substring(2, 4) + checkWord.substring(0, 2);
        return checkWord;
    }

    public static String getMidString(String str, String beginStr, String endStr) {
        String regex = beginStr + "(.*)" + endStr;
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        String result = "";
        while (matcher.find()) {
            result = matcher.group(1);
        }
        return result;
    }

    /**
     * 字符串不足补“0”
     *
     * @param str
     * @param strLength
     * @return
     */
    public static String addZeroForNum(String str, int strLength) {
        int strLen = str.length();
        if (strLen < strLength) {
            while (strLen < strLength) {
                StringBuffer sb = new StringBuffer();
                sb.append("0").append(str);// 左补0
                // sb.append(str).append("0");//右补0
                str = sb.toString();
                strLen = str.length();
            }
        }
        return str;
    }

    /**
     * 字符串不足右边补“0”
     *
     * @param str
     * @param strLength
     * @return
     */
    public static String rightAddZeroForNum(String str, int strLength) {
        int strLen = str.length();
        if (strLen < strLength) {
            while (strLen < strLength) {
                StringBuffer sb = new StringBuffer();
//                sb.append("0").append(str);// 左补0
                sb.append(str).append("0");//右补0
                str = sb.toString();
                strLen = str.length();
            }
        }
        return str;
    }

    /**
     * ip地址转换成16进制long
     *
     * @param ipString
     * @return
     */
    public static String ipToHex(String ipString) {
        String[] strings = ipString.split("\\.");
        String result = "";
        for (int i = 0; i < strings.length; i++) {
            result = result + ExchangeStringUtil.decToHex(strings[i]);
        }
        return result;
    }

    /**
     * ip地址转换成16进制long
     *
     * @param ipString
     * @return
     */
    public static Long ipToLong(String ipString) {
        Long[] ip = new Long[4];
        int pos1 = ipString.indexOf(".");
        int pos2 = ipString.indexOf(".", pos1 + 1);
        int pos3 = ipString.indexOf(".", pos2 + 1);
        ip[0] = Long.parseLong(ipString.substring(0, pos1));
        ip[1] = Long.parseLong(ipString.substring(pos1 + 1, pos2));
        ip[2] = Long.parseLong(ipString.substring(pos2 + 1, pos3));
        ip[3] = Long.parseLong(ipString.substring(pos3 + 1));
        return (ip[0] << 24) + (ip[1] << 16) + (ip[2] << 8) + ip[3];
    }

    public static String splitData(String str, String strStart, String strEnd) {
        String tempStr;
        tempStr = str.substring(str.indexOf(strStart) + 1, str.lastIndexOf(strEnd));
        return tempStr;
    }

    public static String endData(String str, String strStart) {
        String tempStr;
        String str1 = str.substring(0, str.indexOf(strStart));
        tempStr = str.substring(str1.length() + 1);
        return tempStr;
    }

    // 转换位置
    public static String changePosition(String changeStr) {
        StringBuffer s1 = new StringBuffer();
        for (int i = changeStr.length(); i >= 2; i = i - 2) {
            s1 = s1.append(changeStr.substring(i - 2, i));
        }
        return s1.toString();
    }

    // 加33
    public static String addThree(String data) {
        String result = "";
        for (int i = 0; i < data.length() / 2; i++) {
            BigInteger a = new BigInteger(data.substring(2 * i, 2 * (i + 1)), 16);
            BigInteger b = new BigInteger("33", 16);
            BigInteger c = a.add(b);
            result = result + ExchangeStringUtil.decToHex(c.toString(10));
        }

        return result;
    }

    // 减33
    public static String cutThree(String data) {
        String result = "";
        for (int i = 0; i < data.length() / 2; i++) {
            BigInteger a = new BigInteger(data.substring(2 * i, 2 * (i + 1)), 16);
            BigInteger b = new BigInteger("33", 16);
            BigInteger c = a.subtract(b);
            result = result + ExchangeStringUtil.decToHex(c.toString(10));
        }

        return result;
    }

    public static String makeChecksum(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);
            total += Integer.parseInt(s, 16);
            num = num + 2;
        }
        /**
         * 用256求余最大是255，即16进制的FF
         */
        int mod = total % 256;
        String hex = Integer.toHexString(mod);
        len = hex.length();
        // 如果不够校验位的长度，补0,这里用的是两位校验
        if (len < 2) {
            hex = "0" + hex;
        }
        return hex;
    }

    /**
     * 十进制数据转换为十六进制字符串数
     *
     * @param dec
     * @return
     */
    public static String decToHex(String dec) {
        BigInteger data = new BigInteger(dec, 10);
        String result = data.toString(16);
        if (result.length() < 2) {
            result = "0" + result;
        }
        if ((result.length() % 2) != 0) {
            result = "0" + result;
        }
        return result.toUpperCase();
    }

    /**
     * 十六进制数据转换为十进制字符串数
     *
     * @param hex
     * @return
     */
    public static String hexToDec(String hex) {
        BigInteger data = new BigInteger(hex, 16);
        return data.toString(10);
    }

    public static String IntToHex(int n) {
        char[] ch = new char[20];
        int nIndex = 0;
        while (true) {
            int m = n / 16;
            int 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("");
        strHex += sb.toString();
        return strHex;
    }

    // 字节数组转字符串
    public static String printHexString(byte[] b) {

        StringBuffer sbf = new StringBuffer();
        for (int i = 0; i < b.length; i++) {
            String hex = Integer.toHexString(b[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sbf.append(hex.toUpperCase() + "  ");
        }
        return sbf.toString().trim();
    }

    public static String bytesToHexString(byte[] src) {
        StringBuilder stringBuilder = new StringBuilder("");
        if (src == null || src.length <= 0) {
            return null;
        }
        for (int i = 0; i < src.length; i++) {
            int v = src[i] & 0xFF;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                stringBuilder.append(0);
            }
            stringBuilder.append(hv);
        }
        return stringBuilder.toString();
    }

    /**
     * 字符串转化成为16进制字符串
     *
     * @param s
     * @return
     */
    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进制(无需Unicode编码)
     *
     * @param str
     * @return
     */
    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进制转换成为string类型字符串
     *
     * @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, "UTF-8");
            new String();
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        return s;
    }


    /**
     * 字节转十六进制
     *
     * @param b 需要进行转换的byte字节
     * @return 转换后的Hex字符串
     */
    public static String byteToHex(byte b) {
        String hex = Integer.toHexString(b & 0xFF);
        if (hex.length() < 2) {
            hex = "0" + hex;
        }
        return hex;
    }

    /**
     * hex字符串转byte数组
     *
     * @param inHex 待转换的Hex字符串
     * @return 转换后的byte数组结果
     */
    public static byte[] hexToByteArray(String inHex) {
        int hexlen = inHex.length();
        byte[] result;
        if (hexlen % 2 == 1) {
            //奇数
            hexlen++;
            result = new byte[(hexlen / 2)];
            inHex = "0" + inHex;
        } else {
            //偶数
            result = new byte[(hexlen / 2)];
        }
        int j = 0;
        for (int i = 0; i < hexlen; i += 2) {
            result[j] = (byte) Integer.parseInt(inHex.substring(i, i + 2), 16);
            j++;
        }
        return result;
    }

    /**
     * 将十六进制的字符串转换成字节数组
     *
     * @param hexString
     * @return
     */
    public static byte[] hexStrToBinaryStr(String hexString) {

        hexString = hexString.replaceAll(" ", "");

        int len = hexString.length();
        int index = 0;


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

        while (index < len) {

            String sub = hexString.substring(index, index + 2);

            bytes[index / 2] = (byte) Integer.parseInt(sub, 16);

            index += 2;
        }


        return bytes;
    }

    /**
     * 获取当前日期 : "yyyy-MM-dd HH:mm:ss"
     *
     * @return "yyyy-MM-dd HH:mm:ss"字符串
     */
    public static String formatDateStr_ss() {
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
    }

    /**
     * 字符串是否为空
     * <p>
     * 如果这个字符串为null或者trim后为空字符串则返回true，否则返回false。
     *
     * @param str
     * @return
     */
    public static boolean isEmpty(String str) {
        if (str == null || "".equals(str.trim()))
            return true;
        return false;
    }

    /**
     * 用来把mac字符串转换为long
     *
     * @param strMac
     * @return
     */
    public static long macToLong(String strMac) {
        byte[] mb = new BigInteger(strMac, 16).toByteArray();
        ByteBuffer mD = ByteBuffer.allocate(mb.length);
        mD.put(mb);
        long mac = 0;
        // 如果长度等于8代表没有补0;
        if (mD.array().length == 8) {
            mac = mD.getLong(0);
        } else if (mD.array().length == 9) {
            mac = mD.getLong(1);
        }
        return mac;
    }

    public static byte[] getBytes(Object obj) throws IOException {
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(bout);
        out.writeObject(obj);
        out.flush();
        byte[] bytes = bout.toByteArray();
        bout.close();
        out.close();

        return bytes;
    }

    public static Object getObject(byte[] bytes) throws IOException, ClassNotFoundException {
        ByteArrayInputStream bi = new ByteArrayInputStream(bytes);
        ObjectInputStream oi = new ObjectInputStream(bi);
        Object obj = oi.readObject();
        bi.close();
        oi.close();
        return obj;
    }

    public static ByteBuffer getByteBuffer(Object obj) throws IOException {
        byte[] bytes = ExchangeStringUtil.getBytes(obj);
        ByteBuffer buff = ByteBuffer.wrap(bytes);

        return buff;
    }

    /**
     * byte[] 转short 2字节
     *
     * @param bytes
     * @return
     */
    public static short bytesToshort(byte[] bytes) {
        return (short) ((bytes[0] & 0xff) | ((bytes[1] << 8) & 0xff00));

    }

    /**
     * byte 转Int
     *
     * @param b
     * @return
     */
    public static int byteToInt(byte b) {
        return (b) & 0xff;
    }

    public static int bytesToInt(byte[] bytes) {
        int addr = bytes[0] & 0xFF;
        addr |= ((bytes[1] << 8) & 0xFF00);
        addr |= ((bytes[2] << 16) & 0xFF0000);
        addr |= ((bytes[3] << 24) & 0xFF000000);
        return addr;
    }

    public static byte[] intToByte(int i) {

        byte[] abyte0 = new byte[4];
        abyte0[0] = (byte) (0xff & i);
        abyte0[1] = (byte) ((0xff00 & i) >> 8);
        abyte0[2] = (byte) ((0xff0000 & i) >> 16);
        abyte0[3] = (byte) ((0xff000000 & i) >> 24);
        return abyte0;

    }

    public static byte[] LongToByte(Long i) {

        byte[] abyte0 = new byte[8];
        abyte0[0] = (byte) (0xff & i);
        abyte0[1] = (byte) ((0xff00 & i) >> 8);
        abyte0[2] = (byte) ((0xff0000 & i) >> 16);
        abyte0[3] = (byte) ((0xff000000 & i) >> 24);
        abyte0[4] = (byte) ((0xff00000000l & i) >> 32);
        abyte0[5] = (byte) ((0xff0000000000l & i) >> 40);
        abyte0[6] = (byte) ((0xff000000000000l & i) >> 48);
        abyte0[7] = (byte) ((0xff00000000000000l & i) >> 56);
        return abyte0;

    }

    /**
     * 函数名称：shortChange</br>
     * 功能描述：short 大端转小端
     *
     * @param mshort
     */
    public static short shortChange(Short mshort) {

        mshort = (short) ((mshort >> 8 & 0xFF) | (mshort << 8 & 0xFF00));

        return mshort;
    }

    /**
     * 函数名称：intChange</br>
     * 功能描述：int 大端转小端
     *
     * @param mint
     */
    public static int intChange(int mint) {

        mint = (int) (((mint) >> 24 & 0xFF) | ((mint) >> 8 & 0xFF00) | ((mint) << 8 & 0xFF0000)
                | ((mint) << 24 & 0xFF000000));

        return mint;
    }

    /**
     * 函数名称：intChange</br>
     * 功能描述：LONG 大端转小端
     *
     * @param mlong
     */
    public static long longChange(long mlong) {

        mlong = (long) (((mlong) >> 56 & 0xFF) | ((mlong) >> 48 & 0xFF00) | ((mlong) >> 24 & 0xFF0000)
                | ((mlong) >> 8 & 0xFF000000) | ((mlong) << 8 & 0xFF00000000l) | ((mlong) << 24 & 0xFF0000000000l)
                | ((mlong) << 40 & 0xFF000000000000l) | ((mlong) << 56 & 0xFF00000000000000l));

        return mlong;
    }

    /**
     * 将byte转换为无符号的short类型
     *
     * @param b 需要转换的字节数
     * @return 转换完成的short
     */
    public static short byteToUshort(byte b) {
        return (short) (b & 0x00ff);
    }

    /**
     * 将byte转换为无符号的int类型
     *
     * @param b 需要转换的字节数
     * @return 转换完成的int
     */
    public static int byteToUint(byte b) {
        return b & 0x00ff;
    }

    /**
     * 将byte转换为无符号的long类型
     *
     * @param b 需要转换的字节数
     * @return 转换完成的long
     */
    public static long byteToUlong(byte b) {
        return b & 0x00ff;
    }

    /**
     * 将short转换为无符号的int类型
     *
     * @param s 需要转换的short
     * @return 转换完成的int
     */
    public static int shortToUint(short s) {
        return s & 0x00ffff;
    }

    /**
     * 将short转换为无符号的long类型
     *
     * @param s 需要转换的字节数
     * @return 转换完成的long
     */
    public static long shortToUlong(short s) {
        return s & 0x00ffff;
    }

    /**
     * 将int转换为无符号的long类型
     *
     * @param i 需要转换的字节数
     * @return 转换完成的long
     */
    public static long intToUlong(int i) {
        return i & 0x00ffffffff;
    }

    /**
     * 将short转换成小端序的byte数组
     *
     * @param s 需要转换的short
     * @return 转换完成的byte数组
     */
    public static byte[] shortToLittleEndianByteArray(short s) {
        return ByteBuffer.allocate(2).order(ByteOrder.LITTLE_ENDIAN).putShort(s).array();
    }

    /**
     * 将int转换成小端序的byte数组
     *
     * @param i 需要转换的int
     * @return 转换完成的byte数组
     */
    public static byte[] intToLittleEndianByteArray(int i) {
        return ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(i).array();
    }

    /**
     * 将long转换成小端序的byte数组
     *
     * @param l 需要转换的long
     * @return 转换完成的byte数组
     */
    public static byte[] longToLittleEndianByteArray(long l) {
        return ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN).putLong(l).array();
    }

    /**
     * 将short转换成大端序的byte数组
     *
     * @param s 需要转换的short
     * @return 转换完成的byte数组
     */
    public static byte[] shortToBigEndianByteArray(short s) {
        return ByteBuffer.allocate(2).order(ByteOrder.BIG_ENDIAN).putShort(s).array();
    }

    /**
     * 将int转换成大端序的byte数组
     *
     * @param i 需要转换的int
     * @return 转换完成的byte数组
     */
    public static byte[] intToBigEndianByteArray(int i) {
        return ByteBuffer.allocate(2).order(ByteOrder.BIG_ENDIAN).putInt(i).array();
    }

    /**
     * 将long转换成大端序的byte数组
     *
     * @param l 需要转换的long
     * @return 转换完成的byte数组
     */
    public static byte[] longToBigEndianByteArray(long l) {
        return ByteBuffer.allocate(2).order(ByteOrder.BIG_ENDIAN).putLong(l).array();
    }

    /**
     * 将short转换为16进制字符串
     *
     * @param s              需要转换的short
     * @param isLittleEndian 是否是小端序（true为小端序false为大端序）
     * @return 转换后的字符串
     */
    public static String shortToHexString(short s, boolean isLittleEndian) {
        byte byteArray[] = null;
        if (isLittleEndian) {
            byteArray = shortToLittleEndianByteArray(s);
        } else {
            byteArray = shortToBigEndianByteArray(s);
        }
        return byteArrayToHexString(byteArray);
    }

    /**
     * 将int转换为16进制字符串
     *
     * @param i              需要转换的int
     * @param isLittleEndian 是否是小端序（true为小端序false为大端序）
     * @return 转换后的字符串
     */
    public static String intToHexString(int i, boolean isLittleEndian) {
        byte byteArray[] = null;
        if (isLittleEndian) {
            byteArray = intToLittleEndianByteArray(i);
        } else {
            byteArray = intToBigEndianByteArray(i);
        }
        return byteArrayToHexString(byteArray);
    }

    /**
     * 将long转换为16进制字符串
     *
     * @param l              需要转换的long
     * @param isLittleEndian 是否是小端序（true为小端序false为大端序）
     * @return 转换后的字符串
     */
    public static String longToHexString(long l, boolean isLittleEndian) {
        byte byteArray[] = null;
        if (isLittleEndian) {
            byteArray = longToLittleEndianByteArray(l);
        } else {
            byteArray = longToBigEndianByteArray(l);
        }
        return byteArrayToHexString(byteArray);
    }

    /**
     * 将字节数组转换成16进制字符串
     *
     * @param array   需要转换的字符串
     * @param toPrint 是否为了打印输出，如果为true则会每4自己添加一个空格
     * @return 转换完成的字符串
     */
//	public static String byteArrayToHexString(byte[] array, boolean toPrint) {
//		if (array == null) {
//			return "null";
//		}
//		StringBuffer sb = new StringBuffer();
//
//		for (int i = 0; i < array.length; i++) {
//			sb.append(byteToHex(array[i]));
//			if (toPrint && (i + 1) % 4 == 0) {
//				sb.append(" ");
//			}
//		}
//		return sb.toString();
//	}

    /**
     * 字节数组转换成String，指定长度转换长度
     *
     * @param arrBytes
     * @param count    转换长度
     * @param blank    要不要空格（每个byte字节，最是否用一个“ ”隔开）
     * @return "" | arrBytes换成的字符串（不存在null）
     */
    public static String byteArray2HexString(byte[] arrBytes, int count, boolean blank) {
        String ret = "";
        if (arrBytes == null || arrBytes.length < 1)
            return ret;
        if (count > arrBytes.length)
            count = arrBytes.length;
        StringBuilder builder = new StringBuilder();

        for (int i = 0; i < count; i++) {
            ret = Integer.toHexString(arrBytes[i] & 0xFF).toUpperCase();
            if (ret.length() == 1)
                builder.append("0").append(ret);
            else
                builder.append(ret);
            if (blank)
                builder.append(" ");
        }

        return builder.toString();

    }

    public static String hexStr2Str(String hexStr) {
        String string = "0123456789ABCDEF";
        char[] hexs = hexStr.toCharArray();
        byte[] bytes = new byte[hexStr.length() / 2];
        int n;
        for (int i = 0; i < bytes.length; i++) {
            n = string.indexOf(hexs[2 * i]) * 16;
            n += string.indexOf(hexs[2 * i + 1]);
            bytes[i] = (byte) (n & 0xff);
        }
        return new String(bytes);
    }

    /**
     * 将指定字符串src，以每两个字符分割转换为16进制形式 如："2B44EFD9" --> byte[]{0x2B, 0x44, 0xEF, 0xD9}
     *
     * @param src String
     * @return null | byte[]
     */
    public static byte[] HexString2Bytes(String src) {
        // String strTemp = "";
        if (src == null || "".equals(src))
            return null;
        StringBuilder builder = new StringBuilder();
        for (char c : src.trim().toCharArray()) {
            /* 去除中间的空格 */
            if (c != ' ') {
                builder.append(c);
            }
        }
        src = builder.toString();
        byte[] ret = new byte[src.length() / 2];
        byte[] tmp = src.getBytes();
        for (int i = 0; i < src.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;
    }

    /**
     * 将字节数组转换成16进制字符串
     *
     * @param array 需要转换的字符串(字节间没有分隔符)
     * @return 转换完成的字符串
     */
    public static String byteArrayToHexString(byte[] array) {
        return byteArray2HexString(array, Integer.MAX_VALUE, false);
    }

    /**
     * 将字节数组转换成long类型
     *
     * @param bytes 字节数据
     * @return long类型
     */
    public static long byteArrayToLong(byte[] bytes) {
        return ((((long) bytes[0] & 0xff) << 24) | (((long) bytes[1] & 0xff) << 16) | (((long) bytes[2] & 0xff) << 8)
                | (((long) bytes[3] & 0xff) << 0));
    }

    /**
     * 合并数组
     *
     * @param firstArray  第一个数组
     * @param secondArray 第二个数组
     * @return 合并后的数组
     */
    public static byte[] concat(byte[] firstArray, byte[] secondArray) {
        if (firstArray == null || secondArray == null) {
            if (firstArray != null)
                return firstArray;
            if (secondArray != null)
                return secondArray;
            return null;
        }
        byte[] bytes = new byte[firstArray.length + secondArray.length];
        System.arraycopy(firstArray, 0, bytes, 0, firstArray.length);
        System.arraycopy(secondArray, 0, bytes, firstArray.length, secondArray.length);
        return bytes;
    }

    //字符转二进制
    public static String toBinary(String str) {
        char[] strChar = str.toCharArray();
        String result = "";
        for (int i = 0; i < strChar.length; i++) {
            result += Integer.toBinaryString(strChar[i]) + " ";
        }
        System.out.println(result);
        return result;
    }

    /**
     * 将16进制转换为二进制
     *
     * @param hexString
     * @return
     */
    public static String hexString2binaryString(String hexString) {
        //16进制转10进制
        BigInteger sint = new BigInteger(hexString, 16);
        //10进制转2进制
        String result = sint.toString(2);
        //字符串反转
        //return new StringBuilder(result).reverse().toString();
        return result;
    }

    //将十六进制转换为二进制
    public static byte[] parseHexStr2Byte(String str) {
        if (str.length() < 1)
            return null;
        byte[] result = new byte[str.length() / 2];
        for (int i = 0; i < str.length() / 2; i++) {
            int high = Integer.parseInt(str.substring(i * 2, i * 2 + 1), 16);
            int low = Integer.parseInt(str.substring(i * 2 + 1, i * 2 + 2), 16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }

    //将二进制字符转换为十六进制
    public static String parseByte2HexStr(String str) {
        int i = Integer.parseInt(str, 2);   //将二进制转为十进制
        String j = Integer.toHexString(i);       //将十进制转为十六进制
        return j;
    }

    //将二进字节数组制转换为十六进制
    public static String parseByte2HexStr(byte binary[]) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < binary.length; i++) {
            String hex = Integer.toHexString(binary[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * IEEE754字符串转十六进制字符串
     *
     * @param f
     * @author: 若非
     * @date: 2021/9/10 16:57
     */
    public static String singleToHex(float f) {
        int i = Float.floatToIntBits(f);
        String hex = Integer.toHexString(i);
        return hex;
    }

    /**
     * 十六进制字符串转IEEE754浮点型
     *
     * @param s
     * @author: 若非
     * @date: 2021/9/10 16:57
     */
    public static float hexToSingle(String s) {
        BigInteger data = new BigInteger(s, 16);
        return Float.intBitsToFloat(data.intValue());
    }

    //Base64转十六进制字符串
    public static String base64ToHex(String s) {
        try {
            //解码
            byte[] x = Base64.getDecoder().decode(s);
            return Hex.encodeHexString(x);
        } catch (Exception e) {
            return "";
        }
    }

    //十六进制转Base64
    public static String hexToBase64(String s) {
        try {
            //编码
            return encode(hexStringToByteArray(s));
        } catch (Exception e) {
            return "";
        }
    }

    //hex进制转byte[]
    public static byte[] hexStringToByteArray(String s) {
        int len = s.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
                    + Character.digit(s.charAt(i + 1), 16));
        }
        return data;
    }

    /**
     * 获取实时天气2<br>
     * 方 法 名： getTodayWeather <br>
     *
     * @param Cityid 城市编码
     */
    public static Map<String, Object> getTodayWeather1(String Cityid)
            throws IOException, NullPointerException {
        // 连接中央气象台的API
        String url1 = "https://free-api.heweather.net/s6/weather/now?location=" + Cityid + "&key=3c3fa198cacc4152b94b20def11b2455";

        URL url = new URL(url1);
        URLConnection connectionData = url.openConnection();
        connectionData.setConnectTimeout(1000);
        Map<String, Object> map = new HashMap<String, Object>();
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(
                    connectionData.getInputStream(), "UTF-8"));
            StringBuilder sb = new StringBuilder();
            String line = null;
            while ((line = br.readLine()) != null)
                sb.append(line);
            String datas = sb.toString();
            //截取[]转化为json格式
            datas = datas.replace(datas.substring(datas.indexOf(":") + 1, datas.indexOf(":") + 2), "");
            datas = datas.replace(datas.substring(datas.length() - 2, datas.length() - 1), "");
            JSONObject jsonData = JSONObject.parseObject(datas);
            JSONObject info = jsonData.getJSONObject("HeWeather6");
            JSONObject jsonData1 = JSONObject.parseObject(info.getString("basic").toString());
            JSONObject jsonData2 = JSONObject.parseObject(info.getString("update").toString());
            JSONObject jsonData3 = JSONObject.parseObject(info.getString("now").toString());
            map.put("location", jsonData1.getString("location").toString());
            map.put("parent_city", jsonData1.getString("parent_city").toString());
            map.put("admin_area", jsonData1.getString("admin_area").toString());
            map.put("cnty", jsonData1.getString("cnty").toString());

            String time = jsonData2.getString("loc").toString();

            String week = strToDate(time);

            map.put("week", week);
            map.put("time", jsonData2.getString("loc").toString());

            map.put("tmp", jsonData3.getString("tmp").toString());
            map.put("wind_dir", jsonData3.getString("wind_dir").toString());
            map.put("cond_txt", jsonData3.getString("cond_txt").toString());
            map.put("cond_code", jsonData3.getString("cond_code").toString());
            System.out.println(map);
        } catch (SocketTimeoutException e) {
            System.out.println("连接超时");
        } catch (FileNotFoundException e) {
            System.out.println("加载文件出错");
        } catch (ParseException e) {
            e.printStackTrace();
        } finally {
            //关闭流
//            try {
//                if(br!=null){
//                    br.close();
//                }
//
//            } catch ( Exception  e) {
//                e.printStackTrace();
//            }
        }
        return map;
    }

    /**
     * 时间获得星期
     *
     * @param strDate
     * @return
     * @throws ParseException
     */
    public static String strToDate(String strDate) throws ParseException {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
        Calendar c = Calendar.getInstance();
        c.setTime(formatter.parse(strDate));
        SimpleDateFormat sdf = new SimpleDateFormat("EEEE");
        String week = sdf.format(c.getTime());
        return week;
    }

    /**
     * 字符集转码
     *
     * @param url
     * @return
     * @throws UnsupportedEncodingException
     */
    public static String urlEncode(String url) throws UnsupportedEncodingException {
        if (url == null) {
            return null;
        }

        final String reserved_char = ";/?:@=&";
        String ret = "";
        for (int i = 0; i < url.length(); i++) {
            String cs = String.valueOf(url.charAt(i));
            if (reserved_char.contains(cs)) {
                ret += cs;
            } else {
                ret += URLEncoder.encode(cs, "utf-8");
            }
        }
        return ret.replace("+", "%20");
    }


    /**
     * 判断时间是否在时间段内
     *
     * @param date         当前时间 yyyy-MM-dd HH:mm:ss
     * @param strDateBegin 开始时间 00:00:00
     * @param strDateEnd   结束时间 00:05:00
     * @return
     */
    public static boolean isInDate(Date date, String strDateBegin,
                                   String strDateEnd) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String strDate = sdf.format(date);
        // 截取当前时间时分秒
        int strDateH = Integer.parseInt(strDate.substring(11, 13));
        int strDateM = Integer.parseInt(strDate.substring(14, 16));
        int strDateS = Integer.parseInt(strDate.substring(17, 19));//
        // 截取开始时间时分秒
        int strDateBeginH = Integer.parseInt(strDateBegin.substring(0, 2));
        int strDateBeginM = Integer.parseInt(strDateBegin.substring(3, 5));
        int strDateBeginS = Integer.parseInt(strDateBegin.substring(6, 8));//
        // 截取结束时间时分秒
        int strDateEndH = Integer.parseInt(strDateEnd.substring(0, 2));
        int strDateEndM = Integer.parseInt(strDateEnd.substring(3, 5));
        int strDateEndS = Integer.parseInt(strDateEnd.substring(6, 8));//

//        if ((strDateH >= strDateBeginH && strDateH <= strDateEndH)) {
//            // 当前时间小时数在开始时间和结束时间小时数之间
//            if (strDateH > strDateBeginH && strDateH < strDateEndH) {
//                return true;
//                // 当前时间小时数等于开始时间小时数，分钟数在开始和结束之间
//            } else if (strDateH == strDateBeginH && strDateM >= strDateBeginM
//                    && strDateM <= strDateEndM) {
//                return true;
//                // 当前时间小时数等于开始时间小时数，分钟数等于开始时间分钟数，秒数在开始和结束之间
//            } else if (strDateH == strDateBeginH && strDateM == strDateBeginM
//                    && strDateS >= strDateBeginS && strDateS <= strDateEndS) {
//                return true;
//            }
//            // 当前时间小时数大等于开始时间小时数，等于结束时间小时数，分钟数小等于结束时间分钟数
//            else if (strDateH >= strDateBeginH && strDateH == strDateEndH
//                    && strDateM <= strDateEndM) {
//                return true;
//                // 当前时间小时数大等于开始时间小时数，等于结束时间小时数，分钟数等于结束时间分钟数，秒数小等于结束时间秒数
//            } else if (strDateH >= strDateBeginH && strDateH == strDateEndH
//                    && strDateM == strDateEndM && strDateS <= strDateEndS) {
//                return true;
//            } else {
//                return false;
//            }
//        } else {
//            return false;
//        }
        if (strDateS >= strDateBeginS && strDateS < strDateEndS) {
            return true;
        } else {
            return false;
        }

    }

    /**
     * 当前时间向推几小时
     *
     * @param ihour 小时
     * @return String
     */
    public static String dateRoll(int ihour, String curDate) {
        try {
            DateTimeFormatter df1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            SimpleDateFormat df2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            //获取当前时间
            LocalDateTime date = LocalDateTime.now();
            if (curDate.length() > 0) {
                date = dateConvertToLocalDateTime(df2.parse(curDate));
            }
            //获取当前时间的前几小时时间
            LocalDateTime localDateTime = date.minusHours(ihour);
            return df1.format(localDateTime);
        } catch (Exception e) {
            return "";
        }
    }

    //获取当前时间前几分钟
    public static String dateTime(int a, String curDate) {
        try {
            // 设置传入的时间格式
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String currentTime = "";//当前时间
            Calendar cal = Calendar.getInstance();
            if (!curDate.isEmpty()) {
                Date date = df.parse(curDate);
                cal.setTime(date);
            }
            cal.add(Calendar.MINUTE, -a);// a分钟之前的时间
            //格式化指定形式的时间
            currentTime = df.format(cal.getTime());//获取到完整的时间
            return currentTime;
        } catch (Exception e) {
            return "";
        }
    }

    //将java.util.Date 转换为java8 的java.time.LocalDateTime,默认时区为东8区
    public static LocalDateTime dateConvertToLocalDateTime(Date date) {
        return date.toInstant().atOffset(ZoneOffset.of("+8")).toLocalDateTime();
    }


    //将java8 的 java.time.LocalDateTime 转换为 java.util.Date，默认时区为东8区
    public static Date localDateTimeConvertToDate(LocalDateTime localDateTime) {
        return Date.from(localDateTime.toInstant(ZoneOffset.of("+8")));
    }

}