版权归作者LZW所有，转载或使用请注明注明GitHub链接，谢谢合作！
+ * @author LZW + * @version 1.0 + * @date 2019-05-01 + * @website https://github.com/AweiLoveAndroid/CommonDevKnowledge + * @mail lzw20099002@126.com 有任何疑问欢迎发邮件 或者 加微信咨询(本开源库README.md有介绍) + * + */ +public interface CharsetNameTypes { + public static final String CHARSETNAME_UTF8 = "UTF-8"; + public static final String CHARSETNAME_UTF16 = "UTF-16"; + public static final String CHARSETNAME_UTF32 = "UTF-32"; + public static final String CHARSETNAME_UNICODE = "UNICODE"; + public static final String CHARSETNAME_GBK = "GBK"; + public static final String CHARSETNAME_GB2312 = "GB2312"; + public static final String CHARSETNAME_GB18030 = "GB18030"; + public static final String CHARSETNAME_ASCII = "ASCII"; + public static final String CHARSETNAME_ISO_8859_1 = "ISO-8859-1"; +} diff --git a/codes/data_util/com/lzw/data.util/DataUtil.java b/codes/data_util/com/lzw/data.util/DataUtil.java new file mode 100644 index 0000000..92c0f6e --- /dev/null +++ b/codes/data_util/com/lzw/data.util/DataUtil.java @@ -0,0 +1,1145 @@ +package com.lzw.data.util; + +import com.sun.istack.internal.NotNull; + +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; + +/** + * @desp 数据工具类 （史上最完整的工具类，值得收藏） + *byte int short long float double char String 8种类型相互转换 以及不同进制相关转换的工具类
+ *版权归作者LZW所有，转载或使用请注明GitHub链接，谢谢合作！
+ * @author LZW + * @version 1.0 + * @date 2019-05-01 + * @website https://github.com/AweiLoveAndroid/CommonDevKnowledge + * @mail lzw20099002@126.com 有任何疑问欢迎发邮件 或者 加微信咨询(本开源库README.md有介绍) + * + */ +public class DataUtil implements CharsetNameTypes { + + /** + * 用于建立十六进制字符的输出的小写字符数组 + */ + private static final char[] DIGITS_LOWER = {'0', '1', '2', '3', '4', '5', + '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; + + /** + * 用于建立十六进制字符的输出的大写字符数组 + */ + private static final char[] DIGITS_UPPER = {'0', '1', '2', '3', '4', '5', + '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; + + + //////////////////////////////////////////////////////////////////////////////// + /// + /// byte 和 byte 数组转换成其它类型 + /// byte 取值范围：-128（-2^7） 到 127(2^7-1) + //////////////////////////////////////////////////////////////////////////////// + + /** + * byte 转成int + * + * @param byteNumber + * @return{@link #byte2Int2(byte)}
+ */ + public static int byte2Int(@NotNull byte byteNumber) { + // Java的byte是有符号，通过 &0xFF转为无符号 + return byteNumber & 0xFF; + } + + + /** + * byte 转成int + * + * @param byteNumber + * @return{@link #byte2Int(byte)}
+ */ + public static int byte2Int2(@NotNull byte byteNumber) { + return Integer.parseInt(byte2String(byteNumber)); + } + + + /** + * byte数组转成short + * + * @param byteNumber byte数组 + * @return short类型 + * 该方法在某些情况会有精度丢失以及bug, 请谨慎使用。 + */ + public static Short byte2Short(@NotNull byte byteNumber) { + return (short) byteNumber; + } + + + public static long byte2Long(@NotNull byte byteNumber) { + return string2Long(byte2String(byteNumber)); + } + + public static float byte2Float(@NotNull byte byteNumber) { + return string2Float(byte2String(byteNumber)); + } + + public static double byte2Double(@NotNull byte byteNumber) { + return string2Double(byte2String(byteNumber)); + } + + // public static char byte2Char(@NotNull byte byteNumber) { + //// return string2c(byte2String(byteNumber)); + //// } + + + public static String byte2String(@NotNull byte byteNumber) { + return String.valueOf(byteNumber); + } + + /** + * byte数组转成short + * + * @param byteNumber byte数组 + * @return short类型 + */ + public static short byte2Short(@NotNull byte[] byteNumber) { + short result = 0; + for (int i = 0; i < 2; i++) { + result <<= 8; // 意思就是 l = l << 8 + result |= (byteNumber[i] & 0xff); // l = l | (b[i]&0xff) + } + return result; + } + + /** + * byte数组转int + * 10进制 + * + * @param byteArr byte 数组 + * @return int类型 + * {@link #byteArr2Int2(byte[])} 这是另一种写法，其实效果是一样的 + */ + public static int byteArr2Int(@NotNull byte[] byteArr) { + return (byteArr[0] & 0xff) << 24 + | (byteArr[1] & 0xff) << 16 + | (byteArr[2] & 0xff) << 8 + | (byteArr[3] & 0xff); + } + + + /** + * byte数组转成int + * + * @param byteArr byte 数组 + * @return int类型 + * {@link #byteArr2Int(byte[])} 这是另一种写法，其实效果是一样的 + */ + public static int byteArr2Int2(@NotNull byte[] byteArr) { + // 另一种写法，其实效果是一样的 + int num = byteArr[3] & 0xFF; + num |= ((byteArr[2] << 8) & 0xFF00); + num |= ((byteArr[1] << 16) & 0xFF00); + num |= ((byteArr[0] << 24) & 0xFF00); + return num; + } + + /** + * byte[] 转 char + * + * @param byteArr byte数组 + * @return char字符 + */ + public static char byteArr2Char(@NotNull byte[] byteArr) { + char c = (char) (((byteArr[0] & 0xFF) << 8) | (byteArr[1] & 0xFF)); + return c; + } + + + /** + * byte[] 转 char[] （10进制） + * + * @param byteArr byte数组 + * @return char数组 + */ + public static char[] byteArr2CharArr(@NotNull byte[] byteArr) { + Charset cs = Charset.forName("UTF-8"); + ByteBuffer bb = ByteBuffer.allocate(byteArr.length); + bb.put(byteArr); + bb.flip(); + CharBuffer cb = cs.decode(bb); + return cb.array(); + } + + + /** + * byte数组 转成 16进制char数组（默认转换成小写形式） + * + * @param byteArr byte数组 + * @return 16进制char数组 + */ + public static char[] byteArr2CharArrHex(@NotNull byte[] byteArr) { + return byteArr2CharArrHex(byteArr, true); + } + + /** + * byte数组 转成 16进制char数组 + * + * @param byteArr byte数组 + * @param toLowerCase true：转换成小写格式 ，false：转换成大写格式 + * @return 16进制char数组 + */ + public static char[] byteArr2CharArrHex(@NotNull byte[] byteArr, @NotNull boolean toLowerCase) { + return byteArr2CharArrHex(byteArr, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER); + } + + /** + * byte数组 转成 16进制char数组（默认转换成小写形式） + * + * @param byteArr byte数组 + * @param toDigits 用于控制输出的char[] + * @return 16进制char数组 + */ + private static char[] byteArr2CharArrHex(@NotNull byte[] byteArr, @NotNull char[] toDigits) { + int index = 0; + char[] hexChar = new char[byteArr.length * 2];//相当于： char[] out = new char[len << 1]; + for (int i = 0; i < byteArr.length; i++) { + hexChar[index++] = toDigits[byteArr[i] >> 4 & 0xF]; + hexChar[index++] = toDigits[byteArr[i] & 0xF]; + // 无符号位移 + hexChar[index++] = toDigits[(0xF0 & byteArr[i]) >>> 4]; + // 有符号的位移 + // hexChar[j++] = toDigits[byteArr[i] >> 4 & 0xF]; + hexChar[index++] = toDigits[0x0F & byteArr[i]]; + } + return hexChar; + } + + + /** + * byte 数组 转换成String字符串 + * 10进制 + * + * @param byteArr byte 数组 + * @return String字符串 + */ + public static String byteArr2String(@NotNull byte[] byteArr) { + try { + return new String(byteArr, StandardCharsets.UTF_8); + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + + /** + * byte 数组 转换成 16进制的String字符串 + * + * @param byteArr byte 数组 + * @return 16进制的String字符串 + * @deprecated 该方法在某些情况会有bug, 请使用{@link #byteArr2StringHex2(byte[])} 替代。 + */ + @Deprecated + public static String byteArr2StringHex(@NotNull byte[] byteArr) { + StringBuilder stringBuilder = new StringBuilder(""); + if (byteArr == null || byteArr.length <= 0) { + return null; + } + for (int i = 0; i < byteArr.length; i++) { + int v = byteArr[i] & 0xFF; + String hv = Integer.toHexString(v); + if (hv.length() < 2) { + stringBuilder.append(0); + } + stringBuilder.append(hv); + } + return stringBuilder.toString(); + } + + + /** + * 将字节数组转换为十六进制字符串（默认转换成小写形式） + * + * @param byteArr byte 数组 + * @return 16进制的String字符串 + */ + public static String byteArr2StringHex2(@NotNull byte[] byteArr) { + return byteArr2StringHex2(byteArr, true); + } + + + /** + * 将字节数组转换为十六进制字符串 + * + * @param data byte[] + * @param toLowerCase 是否转换成小写形式true 转换成小写格式 ， false 转换成大写格式
+ * @return 十六进制String
+ */
+ public static String byteArr2StringHex2(@NotNull byte[] data, @NotNull boolean toLowerCase) {
+ return byteArr2StringHex2(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
+ }
+
+ /**
+ * 将字节数组转换为十六进制字符串
+ *
+ * @param data byte[]
+ * @param toDigits 用于控制输出的char[]
+ * @return 十六进制String
+ */
+ private static String byteArr2StringHex2(@NotNull byte[] data, @NotNull char[] toDigits) {
+ return charArr2StringHex(byteArr2CharArrHex(data, toDigits));
+ }
+
+
+ ////////////////////////////////////////////////////////////////////////////////
+ ///
+ /// short 和 short 数组转换成其它类型
+ /// short 取值范围：-32768（-2^15）到 32767（2^15 - 1）
+ ////////////////////////////////////////////////////////////////////////////////
+
+
+ /**
+ * short类型转byte数组
+ *
+ * @param shortNumber
+ * @return
+ */
+ public static byte[] short2Byte(@NotNull short shortNumber) {
+ byte[] b = new byte[2];
+ for (int i = 0;
+ i < 2;
+ i++) {
+ int offset = 16 - (i + 1) * 8; //因为byte占4个字节，所以要计算偏移量
+ b[i] = (byte) ((shortNumber >> offset) & 0xff); //把16位分为2个8位进行分别存储
+ }
+ return b;
+ }
+
+ public static int short2Int(@NotNull short shortNumber) {
+ return Integer.parseInt(short2String(shortNumber));
+ }
+
+ public static long short2Long(@NotNull short shortNumber) {
+ return Long.parseLong(short2String(shortNumber));
+ }
+
+ public static float short2Float(@NotNull short shortNumber) {
+ return Float.parseFloat(short2String(shortNumber));
+ }
+
+ public static double short2Double(@NotNull short shortNumber) {
+ return Double.parseDouble(short2String(shortNumber));
+ }
+
+ public static String short2String(@NotNull short shortNumber) {
+ return String.valueOf(shortNumber);
+ }
+
+
+ ////////////////////////////////////////////////////////////////////////////////
+ ///
+ /// int 和 int 数组转换成其它类型
+ /// int 取值范围：-2,147,483,648（-2^31） 到 2,147,483,647（2^31 - 1）
+ ////////////////////////////////////////////////////////////////////////////////
+
+ public static byte int2Byte(@NotNull int intNumber) {
+ // 强转会损失精度
+ return (byte) intNumber;
+ }
+
+
+ /**
+ * int类型 转换成 String类型
+ * 此方法过时，请使用 {@link #int2String2(int)} 或者 {@link #int2String3(int)} 这个方法替代
+ * {@link #int2String(int)}
{@link #int2String2(int)}
也可以把 十六进制数字的基本数据类型 转成 String，例如：int2String2(0xFF);
+ *+ *
{@link #int2String(int)}
{@link #int2String3(int)}
{@link #stringHex2StringDecimal(String)}
{@link #stringHex2IntDecimal(String)}
{@link #int2String(int)}
{@link #int2String2(int)}
{@link #int2ByteArr2(int)} 这是另一种写法，其实效果是一样的
+ */ + public static byte[] int2ByteArr(@NotNull int intNumber) { + // int是4个字节 所以要4个byte + byte[] b = new byte[4]; + b[0] = (byte) (intNumber & 0xff); + b[1] = (byte) ((intNumber >> 8) & 0xff); + b[2] = (byte) ((intNumber >> 16) & 0xff); + b[3] = (byte) ((intNumber >> 24) & 0xff); + return b; + } + + /** + * int转byte数组 + * + * @param intNumber int类型 + * @return byte数组 + * {@link #int2ByteArr(int)} 这是另一种写法，其实效果是一样的 + */ + public static byte[] int2ByteArr2(@NotNull int intNumber) { + // 另一种写法 效果是一样的 + byte[] b = new byte[4]; + b[0] = (byte) ((intNumber >> 24) & 0xFF); + b[1] = (byte) ((intNumber >> 16) & 0xFF); + b[2] = (byte) ((intNumber >> 8) & 0xFF); + b[3] = (byte) (intNumber & 0xFF); + return b; + } + + + ////////////////////////////////////////////////////////////////////////////////////////////// + /// + /// long 和 long 数组转换成其它类型 + /// long 取值范围：-9,223,372,036,854,775,808（-2^63） 到 9,223,372,036,854,775,807（2^63 -1） + ////////////////////////////////////////////////////////////////////////////////////////////// + + + public static byte long2Byte(@NotNull long longNumber) { + return string2Byte(long2String(longNumber)); + } + + public static short long2Short(@NotNull long longNumber) { + return string2Short(long2String(longNumber)); + } + + public static int long2Int(@NotNull long longNumber) { + return Integer.parseInt(long2String(longNumber)); + } + + public static float long2Float(@NotNull long longNumber) { + return string2Float(long2String(longNumber)); + } + + public static double long2Double(@NotNull long longNumber) { + return Double.parseDouble(long2String(longNumber)); + } + + public static String long2String(@NotNull long longNumber) { + return String.valueOf(longNumber); + } + + + //////////////////////////////////////////////////////////////////////////////// + /// + /// float 和 float 数组转换成其它类型 + /// 单精度、32位 + //////////////////////////////////////////////////////////////////////////////// + + + public static byte float2Byte(@NotNull float floatNumber) { + return 0; + } + + public static int float2Short(@NotNull float floatNumber) { + return 0; + } + + public static long float2Int(@NotNull float floatNumber) { + return 0; + } + + public static long float2Long(@NotNull float floatNumber) { + return Long.parseLong(float2String(floatNumber)); + } + + public static double float2Double(@NotNull float floatNumber) { + return Double.parseDouble(float2String(floatNumber)); + } + + public static String float2String(@NotNull float floatNumber) { + return String.valueOf(floatNumber); + } + + + //////////////////////////////////////////////////////////////////////////////// + /// + /// double 和 double 数组转换成其它类型 + /// 双精度、64位 + //////////////////////////////////////////////////////////////////////////////// + + + public static byte double2Byte(@NotNull short doubleNumber) { + return 0; + } + + public static int double2Short(@NotNull short doubleNumber) { + return 0; + } + + public static long double2Int(@NotNull short doubleNumber) { + return 0; + } + + public static long double2Long(@NotNull short doubleNumber) { + return Long.parseLong(double2String(doubleNumber)); + } + + public static float double2Float(@NotNull short doubleNumber) { + return 0; + } + + public static String double2String(@NotNull short doubleNumber) { + return String.valueOf(doubleNumber); + } + + + //////////////////////////////////////////////////////////////////////////////// + /// + /// String 和 String 数组转换成其它类型 + /// + //////////////////////////////////////////////////////////////////////////////// + + /** + * String 转成 byte + * [tips]: 1. + * + * @param data + * @return + */ + public static byte string2Byte(@NotNull String data) { + return string2Byte(data, 10); + } + + /** + * String 转成 byte + * [tips]: 1.不能超过byte取值范围 + * byte取值范围（10进制）是：-128 到 127 + * 换算成2进制是：-10000000 到 1111111 + * 换算成16进制是：-80 到 7f + * + * @param data + * @param radix 进制 比如2、10、16 默认为10进制 + * @return + */ + public static byte string2Byte(@NotNull String data, @NotNull int radix) { + return Byte.parseByte(data, radix); + } + + /** + * String 转成 byte + * 将字符串解码为字节。 + * 接受十进制、十六进制和八进制数: + * 十六进制：0x 0X + * 八进制：0 + * 十进制：- + + * + * @param data + * @return + */ + public static byte string2Byte2(@NotNull String data) { + return Byte.decode(data); + } + + public static short string2Short(@NotNull String data) { + return Short.parseShort(data); + } + + /** + * String转int类型 + * 【注意】： 中文、英文、中英文混合、标点符号、甚至超过byte范围都会报错。 + * unicode码也不行 ，例如：u+4E00、u+4E00、4E00 + * + * @param data + * @return 转成无符号的 int 类型 + *{@link #string2Int(String, boolean)}
+ *{@link #string2IntBinary(String, boolean)}
+ *{@link #string2IntOctal(String, boolean)}
+ *{@link #string2IntHexadecimal(String, boolean)}
+ *{@link #string2Int2(String)}
+ */ + public static int string2Int(@NotNull String data) { + return string2Int(data, false); + } + + + /** + * String转int类型 + * 【注意】： 中文、英文、中英文混合、标点符号、甚至超过byte范围都会报错。 + * unicode码也不行 ，例如：u+4E00、u+4E00、4E00 + * + * @param data + * @param isUnsignedInt 是否要转成无符号的int类型 + * @return int + *{@link #string2Int(String)}
+ *{@link #string2IntBinary(String, boolean)}
+ *{@link #string2IntOctal(String, boolean)}
+ *{@link #string2IntHexadecimal(String, boolean)}
+ *{@link #string2Int2(String)}
+ */ + public static int string2Int(@NotNull String data, @NotNull boolean isUnsignedInt) { + return string2Int(data, isUnsignedInt, 10); + } + + /** + * String转int类型（2进制） + * + * @param data + * @param isUnsignedInt + * @return String字符串 + * {@link #string2Int(String)} + *{@link #string2Int(String, boolean)}
+ *{@link #string2IntOctal(String, boolean)}
+ *{@link #string2IntHexadecimal(String, boolean)}
+ *{@link #string2Int2(String)}
+ */ + public static int string2IntBinary(@NotNull String data, @NotNull boolean isUnsignedInt) { + return string2Int(data, isUnsignedInt, 2); + } + + /** + * String转int类型（8进制） + * + * @param data + * @param isUnsignedInt + * @return String字符串 + *{@link #string2Int(String)}
+ *{@link #string2Int(String, boolean)}
+ *{@link #string2IntBinary(String, boolean)}
+ *{@link #string2IntHexadecimal(String, boolean)}
+ *{@link #string2Int2(String)}
+ */ + public static int string2IntOctal(@NotNull String data, @NotNull boolean isUnsignedInt) { + return string2Int(data, isUnsignedInt, 8); + } + + /** + * String转int类型（16进制） + * + * @param data + * @param isUnsignedInt + * @return int类型 + *{@link #string2Int(String)}
+ *{@link #string2Int(String, boolean)}
+ *{@link #string2IntBinary(String, boolean)}
+ *{@link #string2IntOctal(String, boolean)}
+ *{@link #string2Int2(String)}
+ */ + public static int string2IntHexadecimal(@NotNull String data, @NotNull boolean isUnsignedInt) { + return string2Int(data, isUnsignedInt, 16); + } + + /** + * String转int类型 + * + * @param data + * @param isUnsignedInt + * @param radix 进制 比如2（Binary）、8（Octal）、10（Decimal）、16（Hexadecimal） ，默认为10进制 + * @return int + *{@link #string2Int(String)}
+ *{@link #string2Int(String, boolean)}
+ *{@link #string2IntBinary(String, boolean)}
+ *{@link #string2IntOctal(String, boolean)}
+ *{@link #string2IntHexadecimal(String, boolean)}
+ *{@link #string2Int2(String)}
+ */ + private static int string2Int(@NotNull String data, @NotNull boolean isUnsignedInt, @NotNull int radix) { + if (isUnsignedInt == false) { + return Integer.parseInt(data, radix); + } else { + return Integer.parseUnsignedInt(data, radix); + } + } + + + /** + * String转int类型 + * + * @param data String类型 + * @return int类型 + *{@link #string2Int(String)}
+ *{@link #string2Int(String, boolean)}
+ *{@link #string2IntBinary(String, boolean)}
+ *{@link #string2IntOctal(String, boolean)}
+ *{@link #string2IntHexadecimal(String, boolean)}
+ */ + public static int string2Int2(@NotNull String data) { + return Integer.valueOf(data).intValue(); + } + + + /** + * String转long类型 + * + * @param data + * @return 转成无符号的 long 类型 + */ + public static long string2Long(@NotNull String data) { + return Long.parseLong(data); + } + + /** + * String转 long 类型 + * + * @param data + * @param isUnsignedLong 是否要转成无符号的 long 类型 + * @return 转成的 long 类型 + */ + public static long string2Long(@NotNull String data, @NotNull boolean isUnsignedLong) { + if (isUnsignedLong == false) { + return Long.parseLong(data); + } else { + return Long.parseUnsignedLong(data); + } + } + + public static float string2Float(@NotNull String data) { + return Float.parseFloat(data); + } + + public static double string2Double(@NotNull String data) { + return Double.parseDouble(data); + } + + public static boolean string2Boolean(@NotNull String data) { + return Boolean.parseBoolean(data); + } + + ////////////////////////////////////////////////// + + + //十六进制转十进制，例如：0xFFFF + + // Integer.valueOf("FFFF",16).toString(); //valueOf()方法返回Integer类型，调用toString()返回字符串 + // Integer.parseInt("FFFF",16); //返回int基本数据类型 + // Integer.toString(0xFFFF); //该方法可直接传入表示十六进制数字的基本数据类型，方法返回字符串 + // + // //八进制转十进制，例如：017 + // Integer.valueOf("17",8).toString(); //valueOf()方法返回Integer类型，调用toString()返回字符串 + // Integer.parseInt("17",8); //返回int基本数据类型 + // Integer.toString(017); //该方法可直接传入表示八进制数字的基本数据类型，方法返回字符串 + // + // //二进制转十进制，例如：0101 + // Integer.valueOf("0101",2).toString(); //valueOf()方法返回Integer类型，调用toString()返回字符串 + // Integer.parseInt("0101",2); //返回int基本数据类型 + + // 2（Binary）、8（Octal）、10（Decimal）、16（Hexadecimal） + + //十进制转其他进制 + +//Integer.toHexString(10); //将10转换为十六进制，返回字符串类型 +// +// Integer.toOctalString(10); //将10转为八进制，返回字符串类型 +// +// Integer.toBinaryString(10); //将10转为二进制，返回字符串类型 + + + + + + + + /** + * 16进制 转 10进制 + * + *示例：stringHex2StringDecimal("FFFF");
+ * + *{@link #stringHex2StringDecimal(String)}
+ *{@link #stringHex2IntDecimal(String)}
+ *{@link #int2String2(int)}
+ */ + public static int stringHex2IntDecimal(@NotNull String data) { + return Integer.parseInt(data, 16); + } + + + + + + /** + * 8进制 转 10进制 + * + *示例：stringOctal2StringDecimal("121");
+ * + * @param data 8进制 字符串 + * @return 10进制 字符串 + */ + public static String stringOctal2StringDecimal(@NotNull String data) { + return Integer.valueOf(data, 8).toString(); + } + + /** + * 8进制 转 10进制 + * 示例：stringOctal2IntDecimal("121"); + * + * @param data 8进制 字符串 + * @return 10进制 int类型 + */ + public static int stringOctal2IntDecimal(@NotNull String data) { + return Integer.parseInt(data, 8); + } + + + /** + * 2进制 转 10进制 + * + * @param data 10进制 字符串 + * @return 16进制 字符串 + */ + public static String stringBinary2StringDecimal(@NotNull String data) { + return Integer.valueOf(data, 2).toString(); + } + + /** + * 2进制 转 10进制 + * + * @param data 10进制 字符串 + * @return 16进制 int类型 + */ + public static int stringBinary2IntDecimal(@NotNull String data) { + return Integer.parseInt(data,2); + } + + + /////////////////////////////////////////////////// + + /** + * String字符串转成 byte 数组 + * 默认为utf-8编码格式 + * + * @param data String字符串 + * @return byte 数组 + * 例如：DataUtil.stringHex2ByteArr("好"); + */ + public static byte[] string2ByteArr(@NotNull String data) { + try { + return string2ByteArr(data, null); + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + /** + * String字符串转成 byte 数组 + * + * @param data String字符串 + * @param charsetNametypes 编码格式 默认为utf-8 + * @return byte 数组 + * 例如：DataUtil.string2ByteArrWithCharset("好","utf-16"); + */ + public static byte[] string2ByteArr(@NotNull String data, @NotNull String charsetNametypes) throws Exception { + if (charsetNametypes == null || charsetNametypes.equals("")) { + return data.getBytes("utf-8"); + } else { + if (charsetNametypes.equals(CharsetNameTypes.CHARSETNAME_UTF8) || + charsetNametypes.equals(CharsetNameTypes.CHARSETNAME_UTF16) + || charsetNametypes.equals(CharsetNameTypes.CHARSETNAME_UTF32) + || charsetNametypes.equals(CharsetNameTypes.CHARSETNAME_UNICODE) + || charsetNametypes.equals(CharsetNameTypes.CHARSETNAME_GBK) + || charsetNametypes.equals(CharsetNameTypes.CHARSETNAME_GB2312) + || charsetNametypes.equals(CharsetNameTypes.CHARSETNAME_GB18030) + || charsetNametypes.equals(CharsetNameTypes.CHARSETNAME_ASCII) + || charsetNametypes.equals(CharsetNameTypes.CHARSETNAME_ISO_8859_1)) { + return data.getBytes(charsetNametypes); + } else { + throw new IllegalAccessException("编码格式不正确，请检查编码格式"); + } + } + } + + + /** + * 16进制的String字符串 转换成 byte 数组 + * + * @param data 16进制的String字符串 + * @return byte 数组 + * 例如：DataUtil.stringHex2ByteArr("e4bda0e5a5bd"); + */ + public static byte[] stringHex2ByteArr(@NotNull String data) { + try { + if(isHexadecimal(data)!=true){ + throw new IllegalAccessException("该方法不支持传入的此类型字符串，请使用 string2ByteArr(String)方法替代"); + } + int len = data.length(); + byte[] d = new byte[len / 2]; + for (int i = 0; i < len; i += 2) { + // 两位一组，表示一个字节,把这样表示的16进制字符串，还原成一个进制字节 + d[i / 2] = (byte) ((Character.digit(data.charAt(i), 16) << 4) + Character + .digit(data.charAt(i + 1), 16)); + } + return d; + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + //////////////////////////////////////////////////////////////////////////////// + /// + /// char 和 char 数组 数组转换成其它类型 + /// + //////////////////////////////////////////////////////////////////////////////// + + + public static String char2String(@NotNull char charNumber) { + return String.valueOf(charNumber); + } + + /** + * char 转换成 byte[] 数组 + * + * @param charNumber + * @return + */ + public static byte[] char2ByteArr(@NotNull char charNumber) { + byte[] b = new byte[2]; + b[0] = (byte) ((charNumber & 0xFF00) >> 8); + b[1] = (byte) (charNumber & 0xFF); + return b; + } + + /** + * 将十六进制字符转换成一个整数 + * + * @param ch 十六进制char + * @param index 十六进制字符在字符数组中的位置 + * @return 一个整数 + * @throws RuntimeException 当ch不是一个合法的十六进制字符时，抛出运行时异常 + */ + public static int charHex2Int(@NotNull char ch, @NotNull int index) { + int digit = Character.digit(ch, 16); + if (digit == -1) { + throw new RuntimeException("Illegal hexadecimal character " + ch + + " at index " + index); + } + return digit; + } + + + /** + * char[] 转成 byte[] （10进制） + * + * @param charArr char数组 + * @return byte数组 + */ + public static byte[] charArr2ByteArr(@NotNull char[] charArr) { + Charset cs = Charset.forName("UTF-8"); + CharBuffer cb = CharBuffer.allocate(charArr.length); + cb.put(charArr); + cb.flip(); + ByteBuffer bb = cs.encode(cb); + return bb.array(); + } + + /** + * 将十六进制字符数组转换为字节数组 + * + * @param charArr 十六进制char[] + * @return byte[] 字节数组 + * @throws RuntimeException 如果源十六进制字符数组是一个奇怪的长度，将抛出运行时异常 + */ + public static byte[] charArrHex2ByteArr(@NotNull char[] charArr) { + int len = charArr.length; + if ((len & 0x01) != 0) { + throw new RuntimeException("Odd number of characters."); + } + byte[] out = new byte[len >> 1]; + for (int i = 0, j = 0; j < len; i++) { + int f = charHex2Int(charArr[j], j) << 4; + j++; + f = f | charHex2Int(charArr[j], j); + j++; + out[i] = (byte) (f & 0xFF); + } + return out; + } + + /** + * 将char数组转换成十六进制字符串 + * + * @return + */ + public static String charArr2StringHex(@NotNull char[] charArr) { + return new String(charArr); + } + + //////////////////////////////////////////////////////////////////////////////// + /// + /// 判断是否是2进制、8进制、16进制 + /// 2（Binary）、8（Octal）、10（Decimal）、16（Hexadecimal） + /// 2进制：0和1 + /// 8进制：0开头，例如：0123 （8进制没有8和9） + /// 16进制：0x开头，例如：0x23 + //////////////////////////////////////////////////////////////////////////////// + + + /** + * 判断是否是2进制 + * + * @param data + * @return + */ + public static boolean isBinary(String data) { + String regex = "[0-1]+$"; + if (data.matches(regex)) { + System.out.println(data.toUpperCase() + "是2进制数"); + return true; + } else { + System.out.println(data.toUpperCase() + "不是2进制数"); + return false; + } + } + + /** + * 判断是否是8进制 + * + * @param data + * @return + */ + public static boolean isOctal(String data) { + String substring; + String regex = "[0-7]+$"; + if (data.startsWith("0")) { + substring = data.substring(1); + if (substring.matches(regex)) { + System.out.println(data + "是8进制数"); + return true; + } else { + System.out.println(data + "不是8进制数"); + return false; + } + } else { + return false; + } + } + + /** + * 判断是否是10进制 + * + * @param data + * @return + */ + public static boolean isDecimal(String data) { + if (data.startsWith("0") || data.startsWith("0x") || data.startsWith("0X")) { + System.out.println(data + "不是10进制数"); + return false; + } + String regex = "[0-9]+$"; + if (data.matches(regex)) { + System.out.println(data + "是10进制数"); + return true; + } else { + System.out.println(data + "不是10进制数"); + return false; + } + } + + + /** + * 判断是否是16进制 + * + * @param data + * @return + */ + public static boolean isHexadecimal(String data) { + String regex = "^[A-Fa-f0-9]+$"; + if (data.matches(regex)) { + System.out.println(data + "是16进制数"); + return true; + } else { + System.out.println(data + "不是16进制数"); + return false; + } + } +} diff --git a/codes/data_util/com/lzw/data.util/Test.java b/codes/data_util/com/lzw/data.util/Test.java new file mode 100644 index 0000000..95fbdb5 --- /dev/null +++ b/codes/data_util/com/lzw/data.util/Test.java @@ -0,0 +1,88 @@ +package com.lzw.data.util; + +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.charset.Charset; + +/** + * @desp 测试类 + * @author LZW + * @version 1.0 + * @date 2019-05-01 + * @website https://github.com/AweiLoveAndroid/CommonDevKnowledge + * @mail lzw20099002@126.com 有任何疑问欢迎发邮件 或者 加微信咨询(本开源库README.md有介绍) + * + */ +public class Test { + + public static void main(String[] args) { +// String[] strArr = {"你", "好", "你好", "hell5", "你好hell5"}; +// String[] charsetArr = {"", "utf-8", "utf-16", "utf-32", "unicode", "gbk", "gb2312", "GB18030", "ascii", "ISO-8859-1"}; +// for (String str : strArr) { +// System.out.println(str); +// for (String charset : charsetArr) { +// test(str, charset); +// } +// System.out.println("============================"); +// } + + + System.out.println(DataUtil.stringHex2StringDecimal("FFFF")); // 65535 + + String data = "0x123"; + System.out.println(isDecimal(data)); + } + + public static void test(String data, String charsetName) { + try { + byte[] byteArrays = DataUtil.string2ByteArr(data, charsetName); + String result = DataUtil.byteArr2StringHex2(byteArrays); + if (charsetName.equals("")) { + System.out.println("默认编码：" + charsetName + + " 系统默认编码：" + System.getProperty("file.encoding") + + " 系统默认字符编码:" + Charset.defaultCharset() + + " 操作系统用户使用的语言:" + System.getProperty("user.language") + + " 所占字节数：" + byteArrays.length + + " 16进制：" + result); + } else { + System.out.println("编码：" + charsetName + + " 系统默认编码：" + System.getProperty("file.encoding") + + " 系统默认字符编码:" + Charset.defaultCharset() + + " 操作系统用户使用的语言:" + System.getProperty("user.language") + + " 所占字节数：" + byteArrays.length + + " 16进制：" + result); + } + } catch (Exception e) { + e.printStackTrace(); + } + } + + public static boolean isOctal(String data) { + String substring; + String regex = "[0-7]+$"; + if (data.startsWith("0")) { + substring = data.substring(1); + if (substring.matches(regex)) { + System.out.println(data.toUpperCase() + "是8进制数"); + return true; + } else { + System.out.println(data.toUpperCase() + "不是8进制数"); + return false; + } + } else { + return false; + } + } + + public static boolean isDecimal(String data) { + String regex = "[0-9]+$"; + if (data.matches(regex)) { + System.out.println(data.toUpperCase() + "是10进制数"); + return true; + } else { + System.out.println(data.toUpperCase() + "不是10进制数"); + return false; + } + } + +} \ No newline at end of file