数据类型转换
来源：互联网 发布：什么是java系统类库 编辑：程序博客网 时间：2024/06/07 21:54
import java.io.*;import java.nio.ByteBuffer;import java.nio.ByteOrder;import java.nio.DoubleBuffer;import java.nio.FloatBuffer;import java.text.*;import java.util.Arrays;import java.util.Date;import java.util.List;import java.util.Locale;/** * 数据类型转换帮助器 */public class ConvertHelper { // ------------------------ 数值类型数据转换 ------------------------ /** * 把数据转换为布尔型（默认返回 false） * * @param value * 需要转换的值对象 * @return 尔型值 */ public static boolean toBoolean(Object value) { return toBoolean(value, false); } /** * 把数据转换为布尔型 * * @param value * 需要转换的值对象 * @param defaultValue * 默认值 * @return 尔型值 */ public static boolean toBoolean(Object value, boolean defaultValue) { if (value == null) return defaultValue; if (value instanceof Boolean){ return (Boolean)value; } else if (value instanceof Integer){ return (Integer)value == -1; } else{ String ret = value.toString(); if (ret.length() == 0){ return defaultValue; } else{ return (ret.toLowerCase().equals("true")); } } } /** * 把数据转换为整形（默认返回 0） * * @param value * 需要转换的值对象 * @return 整形数值 */ public static int toInt(Object value) { return toInt(value, 0, 10); } /** * 把数据转换为整形（值转换） * * @param value * 需要转换的值对象 * @param defaultValue * 默认值 * @return 整形数值 */ public static int toInt(Object value, int defaultValue) { return toInt(value, defaultValue, 10); } /** * 把数据转换为整形（值转换） * * @param value * 需要转换的值对象 * @param defaultValue * 默认值 * @param radix * 进制 * @return 整形数值 */ public static int toInt(Object value, int defaultValue, int radix) { if (value == null) return defaultValue; if (value instanceof Integer){ return (Integer)value; } else{ String s = value.toString(); if (s.length() == 0){ return defaultValue; } else{ try{ return Integer.parseInt(s, radix); } catch (Exception e) {} return defaultValue; } } } /** * 把数据转换为短整形（默认返回 0） * * @param value * 需要转换的值对象 * @return 短整形数值 */ public static short toShort(Object value) { return toShort(value, (short)0, 10); } /** * 把数据转换为短整形（值转换） * * @param value * 需要转换的值对象 * @param defaultValue * 默认值 * @return 短整形数值 */ public static short toShort(Object value, short defaultValue) { return toShort(value, defaultValue, 10); } /** * 把数据转换为短整形（值转换） * * @param value * 需要转换的值对象 * @param defaultValue * 默认值 * @param radix * 进制 * @return 短整形数值 */ public static short toShort(Object value, short defaultValue, int radix) { if (value == null) return defaultValue; if (value instanceof Short){ return (Short)value; } else{ String s = value.toString(); if (s.length() == 0){ return defaultValue; } else{ try{ return Short.valueOf(s, radix); } catch (Exception e) {} return defaultValue; } } } /** * 把数据转换为长整数（默认返回 0） * * @param value * 源数据 * @return long 取得的数值 */ public static long toLong(Object value) { return toLong(value, 0L); } /** * 把数据转换为长整数 * * @param value * 源数据 * @param defaultValue * 默认数值 * @return long 取得的数值 */ public static long toLong(Object value, long defaultValue) { if (value == null) return defaultValue; if (value instanceof Long){ return (Long)value; } else{ String s = value.toString(); if (s.length() == 0){ return defaultValue; } else{ try{ return Double.valueOf(s).longValue(); } catch (Exception e) {} return defaultValue; } } } /** * 把数据转换为浮点数（默认返回 0） * * @param value * 源数据 * @return float 浮点数 */ public static float toFloat(Object value) { return toFloat(value, 0F); } /** * 把数据转换为浮点数 * * @param value * 源数据 * @param defaultValue * 默认数值 * @return float 浮点数 */ public static float toFloat(Object value, float defaultValue) { if (value == null) return defaultValue; if (value instanceof Float){ return (Float)value; } else{ String s = value.toString(); if (s.length() == 0){ return defaultValue; } else{ try{ return Double.valueOf(s).floatValue(); } catch (Exception e) {} return defaultValue; } } } /** * 把数据转换为双精度数（默认返回 0） * * @param value * 源数据 * @return double 双精度数 */ public static double toDouble(Object value) { return toDouble(value, 0D); } /** * 把数据转换为双精度数 * * @param value * 源数据 * @param defaultValue * 默认数值 * @return double 双精度数 */ public static double toDouble(Object value, double defaultValue) { if (value == null) return defaultValue; if (value instanceof Double){ return (Double)value; } else{ String s = value.toString(); if (s.length() == 0){ return defaultValue; } else{ try{ return Double.valueOf(s).doubleValue(); } catch (Exception e) {} return defaultValue; } } } /** * 把数据转换为字节值（默认返回 0） * * @param value * 数据数值 * @return 字节值 */ public static byte toByte(Object value) { return toByte(value, (byte)0, 10); } /** * 把数据转换为字节值（值转换） * * @param value * 数据数值 * @param defaultValue * 默认值 * @return 字节值 */ public static byte toByte(Object value, byte defaultValue) { return toByte(value, defaultValue, 10); } /** * 把数据转换为字节值（值转换） * * @param value * 数据数值 * @param defaultValue * 默认值 * @param radix * 进制 * @return 字节值 */ public static byte toByte(Object value, byte defaultValue, int radix) { if (value == null) return defaultValue; if (value instanceof Byte || value instanceof Integer){ return Byte.valueOf(value.toString()); } else{ String s = value.toString(); if (s.length() == 0){ return defaultValue; } else{ try{ byte c=(byte) Integer.parseInt(s, radix); return c; } catch (Exception e) {} return defaultValue; } } } /** * 把数据转换为字节数组（数组转换） * * @param value * 数据数值 * @param radix * 进制 * @return 字节值 */ public static byte[] toByteArray(String value,int radix){ byte[] byteArrays = new byte[value.length()/2]; int j = 0; StringBuffer buf = new StringBuffer(2); for(int i = 0;i<value.length();i++,j++){ buf.insert(0, value.charAt(i)); buf.insert(1, value.charAt(i+1)); int t = Integer.parseInt(buf.toString(),radix); byteArrays[j] = (byte)t; i++; buf.delete(0, 2); } return byteArrays; } /** * 判断两个byte数组是否完全相同 * * @param * * @param * * @return 字节值 */ public static boolean isSameByteArray(byte[] firstByteArray,byte[] secondByteArray){ if(Arrays.equals(firstByteArray, secondByteArray)) return true; else return false; } /** * 根据指定格式把日期数据转换为日期类型 （无效则返回为 null） * * @param value * 字符型日期 * @param format * 格式（"yyyy-MM-dd HH:mm:ss.SSS"） * @return Date 日期 */ public static Date toDate(String value, String format) { return toDate(value, format, null); } /** * 根据指定格式把日期数据转换为日期类型 * * @param value * 字符型日期 * @param format * 格式（"yyyy-MM-dd HH:mm:ss.SSS"） * @param defaultValue * 默认日期 * @return Date 日期 */ public static Date toDate(String value, String format, Date defaultValue) { try { final DateFormat df = new SimpleDateFormat(format); ParsePosition pp = new ParsePosition(0); return df.parse(value, pp); } catch (final Exception e) {} return defaultValue; } /** * 把日期格式化为制定格式字符串（转换失败则返回 null） * * @param date * 日期 * @param format * 格式（yyyy-MM-dd HH:mm:ss.SSS） * @return String 字符型日期 */ public static String toString(Date date, String format) { try { if (date != null) { DateFormat df = new SimpleDateFormat(format); return df.format(date); } } catch (Exception e) {} return null; } /** * 把数值转换为格式化字符串 * * @param number * 数值 * @param format * String 格式化字符串<br/> * #: 表示有数字则输出数字，没有则留空；<br/> * 0: 表示有数字则输出数字，没有补0 对于小数，有几个＃或0，就保留几位的小数； <br/> * 例如：<br/> * "###.00"<br/> * -->表示输出的数值保留两位小数，不足两位的补0，多于两位的四舍五入 "###.0#"<br/> * -->表示输出的数值可以保留一位或两位小数；整数显示为有一位小数，一位或两位小数的按原样显示，多于两位的四舍五入；<br/> * "###"<br/> * --->表示为整数，小数部分四舍五入 ".###" -->12.234显示为.234 "#,###.0#"<br/> * -->表示整数每隔3位加一个"，";<br/> * @return String 格式化后的字符串 */ public static String toString(float number, String format) { return toString((double) number, format); } /** * 把数值转换为格式化字符串 * * @param number * 数值 * @param format * String 格式化字符串<br/> * #: 表示有数字则输出数字，没有则留空；<br/> * 0: 表示有数字则输出数字，没有补0 对于小数，有几个＃或0，就保留几位的小数； <br/> * 例如：<br/> * "###.00"<br/> * -->表示输出的数值保留两位小数，不足两位的补0，多于两位的四舍五入 "###.0#"<br/> * -->表示输出的数值可以保留一位或两位小数；整数显示为有一位小数，一位或两位小数的按原样显示，多于两位的四舍五入；<br/> * "###"<br/> * --->表示为整数，小数部分四舍五入 ".###" -->12.234显示为.234 "#,###.0#"<br/> * -->表示整数每隔3位加一个"，";<br/> * @return String 格式化后的字符串 */ public static String toString(int number, String format) { return toString((double) number, format); } /** * 把数值转换为格式化字符串 * * @param number * 数值 * @param format * String 格式化字符串<br/> * #: 表示有数字则输出数字，没有则留空；<br/> * 0: 表示有数字则输出数字，没有补0 对于小数，有几个＃或0，就保留几位的小数； <br/> * 例如：<br/> * "###.00"<br/> * -->表示输出的数值保留两位小数，不足两位的补0，多于两位的四舍五入 "###.0#"<br/> * -->表示输出的数值可以保留一位或两位小数；整数显示为有一位小数，一位或两位小数的按原样显示，多于两位的四舍五入；<br/> * "###"<br/> * --->表示为整数，小数部分四舍五入 ".###" -->12.234显示为.234 "#,###.0#"<br/> * -->表示整数每隔3位加一个"，";<br/> * @return String 格式化后的字符串 */ public static String toString(long number, String format) { return toString((double) number, format); } /** * 把列表转换为数组字符串，用逗号分隔（返回非 null 字符串） * @param <T> * @param list 列表对象（例如List<Long>） * @return */ public static <T extends Object> String listToString(List<T> list){ StringBuilder sb = new StringBuilder(); if (list != null){ for (int i=0,c=list.size();i<c;i++){ if (i > 0){ sb.append(","); } sb.append(list.get(i)); } } return sb.toString(); } /** * 把列表转换为数组字符串，每个数据用引号包含，用逗号分隔（返回非 null 字符串） * @param <T> * @param list 列表对象（例如List<Long>） * @param invertedComma 引号字符串 * @return */ public static <T extends Object> String listToStringWithInvertedComma(List<T> list, String invertedComma){ StringBuilder sb = new StringBuilder(); if (list != null){ for (int i=0,c=list.size();i<c;i++){ if (i > 0){ sb.append(","); } sb.append(invertedComma + list.get(i) + invertedComma); } } return sb.toString(); } /** * 把数组转化为字符串，用逗号分隔（返回非 null 字符串） * @param array 整形数组 * @return 字符串 */ public static String arrayToString(int[] array){ StringBuilder sb = new StringBuilder(); if (array != null){ for (int i=0,c=array.length;i<c;i++){ if (i > 0){ sb.append(","); } sb.append(array[i]); } } return sb.toString(); } /** * 把数组转化为字符串，用逗号分隔（返回非 null 字符串） * @param array 整形数组 * @return 字符串 */ public static String arrayToString(Object[] array){ StringBuilder sb = new StringBuilder(); if (array != null){ for (int i=0,c=array.length;i<c;i++){ if (i > 0){ sb.append(","); } sb.append(array[i]); } } return sb.toString(); } /** * 把数组转化为字符串，用逗号分隔（返回非 null 字符串） * @param array 长整形数组 * @return 字符串 */ public static String arrayToString(long[] array){ StringBuilder sb = new StringBuilder(); if (array != null){ for (int i=0,c=array.length;i<c;i++){ if (i > 0){ sb.append(","); } sb.append(array[i]); } } return sb.toString(); } /** * 把用逗号分隔的字符串转换为长整形数组（返回非 null 数组） * @param str 字符串 * @return 长整形数组 */ public static long[] stringToLongArray(String str){ String[] array = str.split(","); if (array != null && array.length > 0){ long[] rets = new long[array.length]; for (int i=0,c=array.length;i<c;i++){ rets[i] = toLong(array[i]); } return rets; } return new long[0]; } /** * 把用逗号分隔的字符串转换为长整形数组（返回非 null 数组） * @param str 字符串 * @return 整形数组 */ public static int[] stringToIntArray(String str){ String[] array = str.split(","); if (array != null && array.length > 0){ int[] rets = new int[array.length]; for (int i=0,c=array.length;i<c;i++){ rets[i] = toInt(array[i]); } return rets; } return new int[0]; } /** * 把数值转换为格式化字符串 * * @param number * 数值 * @param format * String 格式化字符串<br/> * #: 表示有数字则输出数字，没有则留空；<br/> * 0: 表示有数字则输出数字，没有补0 对于小数，有几个＃或0，就保留几位的小数； <br/> * 例如：<br/> * "###.00"<br/> * -->表示输出的数值保留两位小数，不足两位的补0，多于两位的四舍五入 "###.0#"<br/> * -->表示输出的数值可以保留一位或两位小数；整数显示为有一位小数，一位或两位小数的按原样显示，多于两位的四舍五入；<br/> * "###"<br/> * --->表示为整数，小数部分四舍五入 ".###" -->12.234显示为.234 "#,###.0#"<br/> * -->表示整数每隔3位加一个"，";<br/> * @return String 格式化后的字符串 */ public static String toString(double number, String format) { String sReturn = ""; DecimalFormat nf = (DecimalFormat) NumberFormat.getInstance(Locale .getDefault()); nf.applyPattern(format); try { sReturn = nf.format(number); } catch (Exception e) { sReturn = nf.format(0); } return sReturn; } // ------------------------ 字符编码转换方法 ------------------------ /** * 把字节数组转换为字符串 * * @param bytes * 字节数组 * @return 字符串 */ public static String bytesToUnicodeUTF8(byte[] bytes) { return bytesToUnicodeString(bytes, "UTF-8"); } /** * 把字节数组转换为字符串 * * @param bytes * 字节数组 * @param charsetName * 字符编码名称（如：UTF-8） * @return 字符串 */ public static String bytesToUnicodeString(byte[] bytes, String charsetName) { try { return new String(bytes, charsetName); } catch (UnsupportedEncodingException e) { return null; } } /** * 把字符串转换为字节数组 * * @param str * 字符串 * @return 字节数组 */ public static byte[] unicodeUTF8ToBytes(String str) { return unicodeStringToBytes(str, "UTF-8"); } /** * 把字符串转换为字节数组 * * @param str * 字符串 * @param charsetName * 字符编码名称（如：UTF-8） * @return 字节数组 */ public static byte[] unicodeStringToBytes(String str, String charsetName) { if (str == null) return null; try { return str.getBytes(charsetName); } catch (UnsupportedEncodingException e) { return null; } } /** * 把整型数据转换为字节数组（从高位到低位） * * @param value * 数据数值 * @return 字节值 */ public static byte[] intToBytes(int value) { byte[] ret = new byte[4]; ret[3] = (byte) (value & 0xff); ret[2] = (byte) ((value >> 8) & 0xff); ret[1] = (byte) ((value >> 16) & 0xff); ret[0] = (byte) (value >>> 24); return ret; } /** * 把长整型数据转换为字节数组（从高位到低位） * * @param value * 数据数值 * @return 字节值 */ public static byte[] longToBytes(long value) { byte[] ret = new byte[8]; for (int i = 0; i < 8; i++) { ret[i] = (byte) (value >>> (56 - i * 8)); } return ret; } /** * 把浮点型数据转换为字节数组（从低位到高位） * * @param value * 数据数值 * @return 字节值 */ public static byte[] floatToBytes(float value) { return floatToBytes(value, ByteOrder.LITTLE_ENDIAN); } /** * 把浮点型数据转换为字节数组 * * @param value * 数据数值 * @return 字节值 */ public static byte[] floatToBytes(float value, ByteOrder order) { ByteBuffer bb = ByteBuffer.allocate(4); bb.order(order); byte[] ret = new byte [4]; FloatBuffer fb = bb.asFloatBuffer(); fb.put(value); bb.get(ret); return ret; } /** * 把双精度浮点型数据转换为字节数组（从低位到高位） * * @param value * 数据数值 * @return 字节值 */ public static byte[] doubleToBytes(double value) { return doubleToBytes(value, ByteOrder.LITTLE_ENDIAN); } /** * 把双精度浮点型数据转换为字节数组 * * @param value * 数据数值 * @return 字节值 */ public static byte[] doubleToBytes(double value, ByteOrder order) { ByteBuffer bb = ByteBuffer.allocate(8); bb.order(order); byte[] ret = new byte [8]; DoubleBuffer fb = bb.asDoubleBuffer(); fb.put(value); bb.get(ret); return ret; } /** * 把字节数组转换为整形（默认返回 0，从高位到低位） * * @param value * 源数据 * @return int 整形 */ public static int bytesToInt(byte[] value) { return bytesToInt(value, ByteOrder.BIG_ENDIAN); } /** * 把字节数组转换为整形（默认返回 0） * * @param value * 源数据 * @return int 整形 */ public static int bytesToInt(byte[] value, ByteOrder order) { if (value == null || value.length == 0) return 0; ByteBuffer buffer = ByteBuffer.wrap(value); buffer.order(order); return buffer.getInt(); } /** * Byte转Bit */ public static String byteToBit(byte b) { return "" +(byte)((b >> 7) & 0x1) + (byte)((b >> 6) & 0x1) + (byte)((b >> 5) & 0x1) + (byte)((b >> 4) & 0x1) + (byte)((b >> 3) & 0x1) + (byte)((b >> 2) & 0x1) + (byte)((b >> 1) & 0x1) + (byte)((b >> 0) & 0x1); } /** * 把字节数组转换为长整形（默认返回 0，从高位到低位） * * @param value * 源数据 * @return long 长整形 */ public static long bytesToLong(byte[] value) { return bytesToLong(value, ByteOrder.BIG_ENDIAN); } /** * 把字节数组转换为长整形（默认返回 0） * * @param value * 源数据 * @return long 长整形 */ public static long bytesToLong(byte[] value, ByteOrder order) { if (value == null || value.length == 0) return 0; ByteBuffer buffer = ByteBuffer.wrap(value); buffer.order(order); return buffer.getLong(); } /** * 把字节数组转换为浮点数（默认返回 0，从低位到高位） * * @param value * 源数据 * @return float 浮点数 */ public static float bytesToFloat(byte[] value) { return bytesToFloat(value, ByteOrder.LITTLE_ENDIAN); } /** * 把字节数组转换为浮点数（默认返回 0） * * @param value * 源数据 * @return float 浮点数 */ public static float bytesToFloat(byte[] value, ByteOrder order) { if (value == null || value.length == 0) return 0; ByteBuffer buffer = ByteBuffer.wrap(value); buffer.order(order); return buffer.getFloat(); } /** * 把字节数组转换为双精度浮点数（默认返回 0，从低位到高位） * * @param value * 源数据 * @return double 浮点数 */ public static double bytesToDouble(byte[] value) { return bytesToDouble(value, ByteOrder.LITTLE_ENDIAN); } /** * 把字节数组转换为双精度浮点数（默认返回 0） * * @param value * 源数据 * @return double 浮点数 */ public static double bytesToDouble(byte[] value, ByteOrder order) { if (value == null || value.length == 0) return 0; ByteBuffer buffer = ByteBuffer.wrap(value); buffer.order(order); return buffer.getDouble(); } /** * 截取指定长度的字节数据 * @param bytes 源字节数组 * @param start 开始位置 * @return byte[] 被截取的字节数组 */ public static byte[] subBytes(byte[] bytes, int start){ if (bytes == null || bytes.length == 0 || start >= bytes.length) return new byte[0]; if (start < 0) start = 0; byte[] ret = new byte[bytes.length - start]; for (int i=start,index=0,c=bytes.length;i<c;i++,index++){ ret[index] = bytes[i]; } return ret; } /** * 截取指定长度的字节数据 * @param bytes 源字节数组 * @param start 开始位置 * @param len 截取长度 * @return byte[] 被截取的字节数组 */ public static byte[] subBytes(byte[] bytes, int start, int len){ byte[] ret = new byte[len]; if (bytes == null || bytes.length == 0) return ret; if (start < 0) start = 0; for (int i=start,index=0,c=bytes.length;index<len&&i<c;i++,index++){ ret[index] = bytes[i]; } return ret; } // ------------------------ 泛类型数据转换 ------------------------ /** * 把字节数组转换为对象 * * @param bytes * 字节数组 * @return 对象 */ @SuppressWarnings("unchecked") public static <T extends Object> T bytesToObject(byte[] bytes) { if (bytes == null) return null; ByteArrayInputStream in = new ByteArrayInputStream(bytes); T o = null; ObjectInputStream oi = null; try { oi = new ObjectInputStream(in); o = (T) oi.readObject(); oi.close(); } catch (Exception e) { if (oi != null) { try { oi.close(); } catch (IOException e1) {} } o = null; } return o; } /** * 把可序列化对象转换成字节数组（返回为 null 表示转换失败） * * @param obj * 数据对象 * @return 字节数组 */ public static byte[] objectToBytes(Serializable obj) { if (obj == null) return null; ByteArrayOutputStream out = new ByteArrayOutputStream(); ObjectOutputStream ot = null; try { ot = new ObjectOutputStream(out); ot.writeObject(obj); ot.flush(); ot.close(); return out.toByteArray(); } catch (IOException e) { if (ot != null) { try { ot.close(); } catch (IOException e1) {} } return null; } } // ------------------------ 十六进制类型数据转换 ------------------------ /** * 把十六进制字符转换为字节值 * * @param c * 字符 * @return 字节值 */ public static byte hexCharToByte(char hexChar) { return (byte) "0123456789ABCDEF".indexOf(hexChar); } /** * 把十六进制字符串转换成字节 * * @param hexString * 十六进制字符串 * @return 字节值 */ public static byte hexStringToByte(String hexString) { return toByte(hexString, (byte) 0, 16); } /** * 把十六进制字符串转换成字节 * * @param hexString * 十六进制字符串 * @param defaultByte * 默认值 * @return 字节值 */ public static byte hexStringToByte(String hexString, byte defaultByte) { return toByte(hexString, defaultByte, 16); } /** * 把十六进制字符串转换成字节数组（返回 null 表示失败） * * @param hexString * 十六进制字符串 * @return 字节数组 */ public static byte[] hexStringToBytes(String hexString) { return hexStringToBytes(hexString, null); } /** * 把十六进制字符串转换成字节数组 * * @param hexString * 十六进制字符串 * @param defaultBytes * 默认值 * @return 字节数组 */ public static byte[] hexStringToBytes(String hexString, byte[] defaultBytes) { int hexLen = 0; if (hexString == null || (hexLen = hexString.length()) == 0) return defaultBytes; if (hexLen == 1) hexString = "0" + hexString; int len = (hexLen / 2); byte[] result = new byte[len]; char[] achar = hexString.toUpperCase().toCharArray(); try { for (int i = 0; i < len; i++) { int pos = i * 2; result[i] = (byte) (hexCharToByte(achar[pos]) << 4 | hexCharToByte(achar[pos + 1])); } return result; } catch (Exception e) { return defaultBytes; } } /** * 把字节转换为十六进制字符串 * * @param b * 字节值 * @return String 十六进制字符串 */ public static String byteToHexString(int b) { String s = Integer.toHexString(b).toUpperCase(); if (s.length() < 2) { s = "0" + s; } return s; } /** * 把字节转换为整数 * * @param b * 字节值 * @return int 整形 */ public static int byteToInt(byte b) { return b & 0xFF; } /** * 把字节转换为十六进制字符串 * * @param b * 字节值 * @return String 十六进制字符串 */ public static String byteToHexString(byte b) { String s = Integer.toHexString(b & 0xFF).toUpperCase(); if (s.length() < 2) { s = "0" + s; } return s; } /** * 把字节数组转换成十六进制字符串（不带分隔符） * * @param bytes * 字节数组 * @return 十六进制字符串 */ public static String bytesToHexString(byte[] bytes) { if (bytes == null) return ""; int c = bytes.length; StringBuffer sb = new StringBuffer(c); String sTemp; for (int i = 0; i < c; i++) { sTemp = Integer.toHexString(0xFF & bytes[i]); if (sTemp.length() < 2) sb.append(0); sb.append(sTemp); } return sb.toString().toUpperCase(); } /** * 把字节数组转换成十六进制字符串 * * @param bytes * 字节数组 * @param colons * 分隔符字符串，例如：“:” * @return 十六进制字符串 */ public static String bytesToHexString(byte[] bytes, String colons) { if (bytes == null) return ""; int c = bytes.length; StringBuffer sb = new StringBuffer(c); String sTemp; for (int i = 0; i < c; i++) { sTemp = Integer.toHexString(0xFF & bytes[i]); if (sTemp.length() < 2) sb.append(0); sb.append(sTemp); if (i < c - 1) { sb.append(colons); } } return sb.toString().toUpperCase(); } /** * 把对象转换为十六进制字符串 * * @param obj * 序列化对象 * @return 十六进制字符串 * @throws IOException */ public static String objectToHexString(Serializable obj) { return bytesToHexString(objectToBytes(obj)); } /** * 把十六进制字符串转化为对象 * * @param hexString * 十六进制字符 * @return 对象 */ public static <T extends Object> T hexStringToObject(String hexString) { return bytesToObject(hexStringToBytes(hexString)); } /** * 功能描述：boolean类型转换为char类型 * @author sofWang * @param bool * @return * create Data 2012-05-24 */ public static char booleanToChar(boolean bool){ if(bool){ return 'Y'; }else{ return 'N'; } } /** * 功能描述：char类型转换为boolean类型 * @param c * @return */ public static boolean charToBoolean(char c){ if(c=='Y'){ return true; }else{ return false; } } /** * 功能描述:把一个字节的8位解析成0和1的char数组 * @author sofWang * @param b 需要解析的字节。 * @return char 数组。 * create Date 2012-12-04 */ public static char[] byteToChars(byte b){ String status_byte = Integer.toHexString(b & 0xFF)+""; Long status_16 = Long.parseLong(status_byte, 16); String status_2 = Long.toBinaryString(status_16); String prefix = ""; if(status_2.length()<8){ for (int i = 0; i <8-status_2.length(); i++) { prefix +="0"; } } String statusStr = prefix+status_2; char[] statusArr = statusStr.toCharArray(); char[] sortStatus = new char[statusArr.length]; for (int i = 0; i < statusArr.length; i++) { sortStatus[i] = statusArr[statusArr.length-1-i]; } return sortStatus; } /** * 功能描述:把字符串转换为十六进制字符串 * @param str 字符串 */ public static String toHexString(String str){ char[] c = str.toCharArray(); String hexString = ""; for (int i = 0; i < c.length; i++) { hexString += Integer.toHexString(c[i]); } return hexString; } //byte数组转换int public static int bytes2Int(byte[] intByte) { int num = 0; for (int i = 0; i < intByte.length&&i<4; i++) { num += (intByte[i]&0xFF)*(Math.pow(256, intByte.length-1-i)); } return num; } //将16进制整形转化为10进制整形。 public static int hexIntToInt(int number){ //将整形转为char数组 char[] numberArray = Integer.toString(number).toCharArray(); int result = 0; //遍历每个char for(int i = 0;i < numberArray.length;i++){ result += Math.pow(16,numberArray.length-i-1)*(numberArray[i]-'0'); } return result; }}
阅读全文
0 0
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 数据类型转换
- 238. Product of Array Except Self(Java)
- 条码控件Dynamsoft Barcode Reader教程：从PDF417驾驶执照中提取数据
- 三、rabbitMQ helloWorld入门程序
- https://vuejs.org/v2/examples/svg.html
- CS20SI Tensorflow for Deeplearning课程笔记(四) word2vec with NCE loss and visualize the embeddings
- 数据类型转换
- POJ.Find The Multiple
- D
- 在CentOS7上安装RabbitMQ
- Spring Data JPA 多属性排序
- Spring集成redis实现session共享（无视服务器）
- String类的增删查改（深拷贝，现代写法）
- 01-JS特效-三大系列之offset系列
- HTML
