public class AppTest {
    /**
     * Rigorous Test :-)
     */
    @Test
    public void shouldAnswerWithTrue() {
        int hex = 16;
        System.out.println("獲取16進制字符串數(shù)據(jù):" + BitOperator.intToHexString(hex, 2));
        System.out.println("獲取int類型0-8位的位數(shù)據(jù):" + BitOperator.intNumberRightBitRangeOperator(999, 0, 8));
        System.out.println("獲取int類型9-10位的位數(shù)據(jù)：" + BitOperator.intNumberRightBitRangeOperator(999, 8, 10));
        System.out.println("獲取int類型10-12位的位數(shù)據(jù)：" + BitOperator.intNumberRightBitRangeOperator(256, 10, 12));
        short value = 256;
        System.out.println("獲取short類型10-12位的位數(shù)據(jù)：" + BitOperator.shortNumberRightBitRangeOperator(value, 8, 12));

        //序列化與反序列化對象
        byte[] bytes = BitOperator.objToBytes(new A());
        A object = (A) BitOperator.bytesToObject(bytes);
        System.out.println(object);

        //轉換int數(shù)據(jù)
        int intV = 12738123;
        byte[] bytes1 = {
            (byte) ((intV >> 24) & 0xff),
            (byte) ((intV >> 16) & 0xff),
            (byte) ((intV >> 8) & 0xff),
            (byte) (intV & 0xff)
        };

        byte[] bytes2 = BitOperator.intNumberToBytes(intV);
        int intNumber = BitOperator.bytesToIntNumber(bytes2);

        //轉換short類型
        short sv = 999;
        byte[] bytes3 = {
            (byte) ((sv >> 8) & 0xff),
            (byte) (sv & 0xff)
        };
        short i = BitOperator.bytesToShortNumber(bytes3);
        System.out.println(i);
    }

    @ToString
    public static class A implements Serializable {
        public String name = "zs";

    }
}

@SuppressWarnings("all")
public class BitOperator {
    /** DIGITAL */
    public static final String DIGITAL = "0123456789ABCDEF";
    /** 16進制表示符 */
    public static final String HEX = "0x";
    /**
     * 數(shù)組轉換成 int類型
     *
     * @param value value
     * @return the byte [ ]
     * @since 1.0
     */
    public static byte[] intNumberToBytes(int value) {
        return new byte[] {
            byteNumberRightBitRangeOperator(value, 24, 32),
            byteNumberRightBitRangeOperator(value, 16, 24),
            byteNumberRightBitRangeOperator(value, 8, 16),
            byteNumberRightBitRangeOperator(value, 0, 8)
        };
    }

    /**
     * Short number to bytes
     *
     * @param value value
     * @return the byte [ ]
     * @since 1.0
     */
    public static byte[] shortNumberToBytes(short value) {
        return new byte[] {
            (byte) shortNumberRightBitRangeOperator(value, 8, 16),
            (byte) shortNumberRightBitRangeOperator(value, 0, 8)
        };
    }

    /**
     * 數(shù)組轉換成int數(shù)據(jù)
     *
     * @param bytes bytes
     * @return the int
     * @since 1.0
     */
    public static int bytesToIntNumber(byte[] bytes) {
        return bytesToNumberValue(bytes,0, (res, value) -> {
            return value | res;
        });
    }

    /**
     * 將數(shù)組轉換成short類型
     *
     * @param bytes bytes
     * @return the int
     * @since 1.0
     */
    public static short bytesToShortNumber(byte[] bytes) {
        return bytesToNumberValue(bytes, (short) 0, (res, value) -> {
            return (short) (res | value);
        });
    }

    /**
     * Bytes to number value
     *
     * @param <T>      parameter
     * @param bytes    bytes
     * @param value    value
     * @param function function
     * @return the t
     * @since 1.0
     */
    public static <T extends Number> T bytesToNumberValue(byte[] bytes,
                                                          T value,
                                                          BiFunction<Integer, T, T> function) {
        try {
            int tmp = bytes.length * 8;
            for (int i = 0; i < bytes.length; i++) {
                tmp -= 8;
                value = function.apply(((bytes[i] & 0xff) << tmp), value);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return value;
    }

    /**
     * 16進制字符串轉換為字節(jié)數(shù)組
     *
     * @param str str
     * @return the byte [ ]
     * @since 1.0
     */
    public static byte[] hexStringToByteArray(String str) {
        int len = str.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(str.charAt(i), 16) << 4)
                                  + Character.digit(str.charAt(i + 1), 16));
        }
        return data;
    }

    /**
     * 字節(jié)數(shù)組轉換為16進制字符串
     *
     * @param src src
     * @return string string
     * @since 2022.1.1
     */
    public static String bytesArrayToHexString(byte[] src) {
        StringBuilder stringBuilder = new StringBuilder();
        if (src == null || src.length <= 0) {
            return null;
        }
        for (byte b : src) {
            int v = b & 0xFF;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                stringBuilder.append(0);
            }
            stringBuilder.append(hv);
        }
        return stringBuilder.toString();
    }

    /**
     * 16進制字符串轉換為字節(jié)數(shù)組
     *
     * @param hex hex
     * @return byte [ ]
     * @since 1.0
     */
    public static byte[] stringToBytes(String hex) {
        String hex1 = hex.replace(" ", "");
        char[] hex2char = hex1.toCharArray();
        byte[] bytes = new byte[hex1.length() / 2];
        byte temp;
        for (int p = 0; p < bytes.length; p++) {
            temp = (byte) (DIGITAL.indexOf(hex2char[2 * p]) * 16);
            temp += DIGITAL.indexOf(hex2char[2 * p + 1]);
            bytes[p] = (byte) (temp & 0xff);
        }
        return bytes;
    }

    /**
     * string字符串轉換為 16進制字符串
     *
     * @param hex hex
     * @return the string
     * @since 1.0
     */
    public static String stringToHexString(String s) {
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            int ch = (int) s.charAt(i);
            String s4 = Integer.toHexString(ch);
            str.append(s4);
        }
        return HEX + str.toString();
    }

    /**
     * int類型轉換為16進制字符串
     *
     * @param value  value
     * @param number 不足指定位數(shù)補零
     * @return the string
     * @since 1.0
     */
    public static String intToHexString(int value, int number) {
        return numberValueToHexString(value, number, true);
    }

    /**
     * long類型轉換為16進制字符串
     *
     * @param value  value
     * @param number number
     * @return the string
     * @since 1.0
     */
    public static String longToHexString(long value, int number) {
        return numberValueToHexString(value, number, true);
    }
    /**
     * 數(shù)字類型類型轉換為16進制字符串
     *
     * @param value     value
     * @param number    number
     * @param isShowHex 是否拼接Ox
     * @return the string
     * @since 1.0
     */
    public static String numberValueToHexString(Object value, int number, boolean isShowHex) {
        if (number <= 0) {
            number = 2;
        }
        String hex = String.format("%0" + number + "x", value);
        return isShowHex ? HEX + hex : hex;
    }

    /**
     * 獲取指定位的位數(shù)據(jù)
     *
     * @param value     value
     * @param bitNumber bit number
     * @return the int
     * @since 1.0
     */
    public static int intNumberRightBitOperator(int value, int bitNumber) {
        return bitNumberOperator(32, bitNumber, str -> str != null ? ((value & Integer.parseUnsignedInt(str, 2)) >> bitNumber)  : 0);
    }

    /**
     * 獲取Long類型指定位數(shù)的數(shù)據(jù)
     *
     * @param value     value
     * @param bitNumber bit number
     * @return the int
     * @since 1.0
     */
    public static Long longNumberRightBitOperator(long value, int bitNumber) {
        return bitNumberOperator(64, bitNumber, str -> str != null ? ((value & Long.parseUnsignedLong(str, 2)) >> bitNumber)  : 0);
    }

    /**
     * 獲取指定位的數(shù)據(jù)
     *
     * @param <T>      parameter
     * @param valueBit 數(shù)據(jù)類型的長度，例如int：32位
     * @param number   表示取多少位的數(shù)據(jù)
     * @param func     func
     * @return the int
     * @since 1.0
     */
    public static <T> T bitNumberOperator(int valueBit, int number, Function<String, T> func) {
        if (number > valueBit) {
            return (T) new Integer(0);
        }
        //獲取到位的長度，根據(jù)長度生成對應的二進制位數(shù)據(jù)，獲取數(shù)據(jù)需要生成 1
        StringBuilder builder = new StringBuilder();
        number = valueBit - number;
        for (int i = 0; i < valueBit; i++) {
            if (i == number) {
                builder.append("1");
            } else {
                builder.append("0");
            }
        }
        return func.apply(builder.toString());
    }
    /**
     * 獲取int類型數(shù)據(jù)指定范圍的數(shù)據(jù)
     *
     * @param value value
     * @param start start
     * @param end   end
     * @return the int
     * @since 1.0
     */
    public static int intNumberRightBitRangeOperator(int value, int start, int end) {
        return bitNumberRangeOperator(start, end, 32, str -> str != null ? ((value & Integer.parseUnsignedInt(str, 2)) >> start) : 0);
    }

    /**
     * 獲取int類型數(shù)據(jù)指定范圍的數(shù)據(jù)
     *
     * @param value value
     * @param start start
     * @param end   end
     * @return the int
     * @since 1.0
     */
    public static byte byteNumberRightBitRangeOperator(int value, int start, int end) {
        return (byte) intNumberRightBitRangeOperator(value, start, end);
    }

    /**
     * 獲取short類型指定范圍位數(shù)的數(shù)據(jù)
     *
     * @param value value
     * @param start start
     * @param end   end
     * @return the int
     * @since 1.0
     */
    public static short shortNumberRightBitRangeOperator(short value, int start, int end) {
        return bitNumberRangeOperator(start, end, 16, str -> (short) (str != null ? ((value  & Short.parseShort(str, 2)) >> start) : 0));
    }

    /**
     * 獲取指定位的數(shù)據(jù)
     *
     * @param <T>        parameter
     * @param start      start
     * @param end        end
     * @param typeLength type length
     * @param func       func
     * @return the int
     * @since 1.0
     */
    public static <T> T bitNumberRangeOperator(int start, int end, int typeLength, Function<String, T> func) {
        if (start > end) {
            return (T) new Integer(0);
        }
        //獲取到位的長度，根據(jù)長度生成對應的二進制位數(shù)據(jù)，獲取數(shù)據(jù)需要生成 1
        StringBuilder builder = new StringBuilder();
        for (int i = typeLength - 1; i >= 0; i--) {
            if (i >= start && i < end) {
                builder.append("1");
            } else {
                builder.append("0");
            }
        }
        return func.apply(builder.toString());
    }


    /**
     * obj對象轉換為字節(jié)數(shù)組
     *
     * @param obj obj
     * @return the string
     * @since 1.0
     */
    public static byte[] objToBytes(Object obj) {
        ByteArrayOutputStream objByteArray = new ByteArrayOutputStream();
        byte[] result;
        try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(objByteArray);) {
            objectOutputStream.writeObject(obj);
            objectOutputStream.flush();
            objectOutputStream.close();
            result = objByteArray.toByteArray();
        } catch (IOException e) {
            throw new RuntimeException("對象數(shù)據(jù)轉換異常:" + e.getMessage());
        }
        return result;
    }

    /**
     * 反序列化對象
     *
     * @param bytes bytes
     * @return the object
     * @since 1.0
     */
    public static Object bytesToObject(byte[] bytes) {
        ByteArrayInputStream arrayInputStream = new ByteArrayInputStream(bytes);
        Object result = null;
        try(ObjectInputStream objectInputStream = new ObjectInputStream(arrayInputStream);) {
            result = objectInputStream.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return result;
    }
}