Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
net.lulihu.ObjectKit.ConvertKit Maven / Gradle / Ivy
package net.lulihu.ObjectKit;
import net.lulihu.dateTime.DateTimeKit;
import net.lulihu.exception.ToolBoxException;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.text.NumberFormat;
import java.util.Date;
import java.util.Set;
/**
* 类型转换器
*/
public class ConvertKit {
private ConvertKit() {
// 静态类不可实例化
}
/**
* 强制转换类型
*
* @param clazz 被转换成的类型
* @param value 需要转换的对象
* @return 转换后的对象
*/
public static Object parse(Class clazz, Object value) {
try {
if (clazz.isAssignableFrom(String.class)) {
// 防止sql对空字符串不检测导致无法入库的问题
if (StrKit.isBlank(String.valueOf(value)))
return " ";
else
return String.valueOf(value);
}
return clazz.cast(value);
} catch (ClassCastException e) {
String valueStr = String.valueOf(value);
Object result = parseBasic(clazz, valueStr);
if (result != null) return result;
if (Date.class.isAssignableFrom(clazz)) {
// 判断标准日期
// 需要加toDate(),不然sql转换date类型的时候会报错
return DateTimeKit.parse(valueStr).toDate();
} else if (clazz == BigInteger.class) {
// 数学计算数字
return new BigInteger(valueStr);
} else if (clazz == BigDecimal.class) {
// 数学计算数字
return new BigDecimal(valueStr);
} else if (clazz == byte[].class) {
// 流，由于有字符编码问题，在此使用系统默认
return valueStr.getBytes();
}
// 未找到可转换的类型，抛出异常
return new ToolBoxException("未找到可转换的类型...");
}
}
/**
* 转换基本类型null，或者转换失败，返回默认值nullnull，或者转换失败，返回默认值nullnull，或者转换失败，返回默认值null，或者转换失败，返回默认值nullnull，或者转换失败，返回默认值null，或者转换失败，返回默认值nullnullnull，或者转换失败，返回默认值nullnull，或者转换失败，返回默认值nullnullnull Float[] toFloatArray(boolean isIgnoreConvertError, Object... values) {
if (CollectionKit.isEmpty(values)) {
return new Float[]{};
}
final Float[] floats = new Float[values.length];
for (int i = 0; i < values.length; i++) {
final Float v = toFloat(values[i], null);
if ((null == v) && !isIgnoreConvertError) {
throw new ToolBoxException(StrKit.format("转换[{}]为Float类型时发生例外!", values[i]));
}
floats[i] = v;
}
return floats;
}
/**
* 转换为booleannull> E toEnum(Class clazz, Object value, E defaultValue) {
if (value == null) {
return defaultValue;
}
if (clazz.isAssignableFrom(value.getClass())) {
return (E) value;
}
final String valueStr = toStr(value, null);
if (StrKit.isBlank(valueStr)) {
return defaultValue;
}
try {
return Enum.valueOf(clazz, valueStr);
} catch (Exception e) {
return defaultValue;
}
}
/**
* 转换为Enum对象null> E toEnum(Class clazz, Object value) {
return toEnum(clazz, value, null);
}
/**
* 转换为BigIntegernull notConvertSet) {
char[] c = input.toCharArray();
for (int i = 0; i < c.length; i++) {
if (null != notConvertSet && notConvertSet.contains(c[i])) {
// 跳过不替换的字符
continue;
}
if (c[i] == ' ') {
c[i] = '\u3000';
} else if (c[i] < '\177') {
c[i] = (char) (c[i] + 65248);
}
}
return new String(c);
}
/**
* 全角转半角
*
* @param input String.
* @return 半角字符串
*/
public static String toDBC(String input) {
return toDBC(input, null);
}
/**
* 替换全角为半角
*
* @param text 文本
* @param notConvertSet 不替换的字符集合
* @return 替换后的字符
*/
public static String toDBC(String text, Set notConvertSet) {
char[] c = text.toCharArray();
for (int i = 0; i < c.length; i++) {
if (null != notConvertSet && notConvertSet.contains(c[i])) {
// 跳过不替换的字符
continue;
}
if (c[i] == '\u3000') {
c[i] = ' ';
} else if (c[i] > '\uFF00' && c[i] < '\uFF5F') {
c[i] = (char) (c[i] - 65248);
}
}
return new String(c);
}
// ------------------------------- hex
/**
* String的字符串转换成unicode的String
*
* @param strText 全角字符串
* @return String 每个unicode之间无分隔符
*/
public static String strToUnicode(String strText) {
char c;
StringBuilder str = new StringBuilder();
int intAsc;
String strHex;
for (int i = 0; i < strText.length(); i++) {
c = strText.charAt(i);
intAsc = (int) c;
strHex = Integer.toHexString(intAsc);
if (intAsc > 128)
str.append("\\u").append(strHex);
else // 低位在前面补00
str.append("\\u00").append(strHex);
}
return str.toString();
}
/**
* unicode的String转换成String的字符串
*
* @param hex 16进制值字符串 （一个unicode为2byte）
* @return String 全角字符串
*/
public static String unicodeToStr(String hex) {
int t = hex.length() / 6;
StringBuilder str = new StringBuilder();
for (int i = 0; i < t; i++) {
String s = hex.substring(i * 6, (i + 1) * 6);
// 高位需要补上00再转
String s1 = s.substring(2, 4) + "00";
// 低位直接转
String s2 = s.substring(4);
// 将16进制的string转为int
int n = Integer.valueOf(s1, 16) + Integer.valueOf(s2, 16);
// 将int转换为字符
char[] chars = Character.toChars(n);
str.append(new String(chars));
}
return str.toString();
}
/**
* 给定字符串转换字符编码
