字符串的一些判断

* 判断为标点符号(去除乱码、字母、数字、中文的其他所有)
*
* @param c
*            字符
* @return 是否为标点符号
*/
public static boolean isPunctuation(char c) {
return haveMessyCode(String.valueOf(c)) ? false : isChinese(c) ? false : isLetterOrDigit(c) ? false : true;
}

/**
* 判断一个char是否为中文。
*
* @param c
*            字符
* @return 是否为中文
*/
public static boolean isChinese(char c) {
Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A || ub == Character.UnicodeBlock.GENERAL_PUNCTUATION || ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS) {
return true;
}
return false;
}

/**
* 判断为数字或者字母
*
* @param c
*            字符
* @return 是否为数字或者字母
*/
public static boolean isLetterOrDigit(char c) {
return Character.isLetterOrDigit(c);
}

/**
* 判断字符串是否是乱码
*
* @param strName
*            字符串
* @return 是否是乱码
*/
public static boolean haveMessyCode(String strName) {
Pattern p = Pattern.compile("\\s*|\t*|\r*|\n*");
Matcher m = p.matcher(strName);
String after = m.replaceAll("");
String temp = after.replaceAll("\\p{P}", "");
char[] ch = temp.trim().toCharArray();
float chLength = ch.length;
float count = 0;
for (int i = 0; i < ch.length; i++) {
char c = ch[i];
if (!Character.isLetterOrDigit(c)) {
if (!isChinese(c)) {
count = count + 1;
}
}
}
float result = count / chLength;
if (result > 0.4) {
return true;
} else {
return false;
}

}

/**
* @param str
*            原型字符串
* @param repeat
*            重复次数
* @return 新建的字符串
*/
public static String build(String str, int repeat) {
StringBuffer buf = new StringBuffer();
for (int i = 0; i < repeat; i++) {
buf.append(str);
}
return buf.toString();
}

/**
* 校验字符串
*
* @param str
* @return
*/
public static boolean checkStr(String str) {
boolean flag = true;
int length = Strings.nullToEmpty(str).trim().length();
for (int i = 0; i < length; i++) {
char charAt = str.charAt(i);
if (filterStr(charAt) == true) {
continue;
}
if (checkType(charAt).toString().equals(CharType.OTHER.toString())) {
flag = false;
break;
}
}
return flag;
}

public static boolean filterStr(char c) {
String filter = "$ \n……    。`^><》《“”+=——~【】|";
boolean flag = false;
int length = filter.length();
for (int i = 0; i < length; i++) {
if (filter.charAt(i) == c) {
flag = true;
}
}
return flag;
}

enum CharType {
DELIMITER, // 非字母截止字符，例如，．）（ 等等 （ 包含U0000-U0080）
NUM, // 2字节数字１２３４
LETTER, // gb2312中的，例如:ＡＢＣ，2字节字符同时包含 1字节能表示的 basic latin and latin-1
OTHER, // 其他字符
CHINESE; // 中文字
}

/**
* 判断输入char类型变量的字符类型
*
* @param c
*            char类型变量
* @return CharType 字符类型
*/
private static CharType checkType(char c) {
CharType ct = null;
if (haveMessyCode(String.valueOf(c))) {
ct = CharType.OTHER;
return ct;
}
// 中文，编码区间0x4e00-0x9fbb
if ((c >= 0x4e00) && (c <= 0x9fbb)) {
ct = CharType.CHINESE;
// Halfwidth and Fullwidth Forms， 编码区间0xff00-0xffef
} else if ((c >= 0xff00) && (c <= 0xffef)) { // 2字节英文字
if (((c >= 0xff21) && (c <= 0xff3a)) || ((c >= 0xff41) && (c <= 0xff5a))) {
ct = CharType.LETTER;
// 2字节数字
} else if ((c >= 0xff10) && (c <= 0xff19)) {
ct = CharType.NUM;
} else {
ct = CharType.DELIMITER;
}
} // basic latin，编码区间 0000-007f
else if ((c >= 0x0021) && (c <= 0x007e)) { // 1字节数字
if ((c >= 0x0030) && (c <= 0x0039)) {
ct = CharType.NUM;
} // 1字节字符
else if (((c >= 0x0041) && (c <= 0x005a)) || ((c >= 0x0061) && (c <= 0x007a))) {
ct = CharType.LETTER;
} // 其他字符，可以认为是标点符号
else {
ct = CharType.DELIMITER;
}
} // latin-1，编码区间0080-00ff
else if ((c >= 0x00a1) && (c <= 0x00ff)) {
if ((c >= 0x00c0) && (c <= 0x00ff)) {
ct = CharType.LETTER;
} else
ct = CharType.DELIMITER;
} else {
ct = CharType.OTHER;
}
return ct;
}

/**
* 校验手机端字符串
*
* @param str
* @param length
* @param jsonResult
* @return
*/
public static JsonResult checkStr(String str, int length, JsonResult jsonResult, String message) {
jsonResult = new JsonResult(true);
if (null != str) {
if (!StringUtil.checkStr(str)) {
jsonResult = new JsonResult(false, message + AppConstants.INPUT_RULE_MSG);
return jsonResult;
}
if (str.length() > length) {
jsonResult = new JsonResult(false, message + "最大长度不能超过" + length);
return jsonResult;
}
}
return jsonResult;
}

public static JsonResult checkStr(String str, int length, JsonResult jsonResult) {
return checkStr(str, length, jsonResult, "");
}

/**
* 校验手机端特殊字符进行base64转码
*
* @param str
* @return
* @throws UnsupportedEncodingException
* @throws Exception
*/
public static JsonResult convertStr(String str, int length, JsonResult jsonResult) throws UnsupportedEncodingException, Exception {
if (!Strings.isNullOrEmpty(str)) {
if (str.length() > length) {
jsonResult = new JsonResult(false, "最大长度不能超过" + length);
return jsonResult;
}
str = Base64.encode(str, "utf-8");
}
jsonResult = new JsonResult(true);
jsonResult.setData(str);
return jsonResult;
}

/**
* 字符串base64编码
*
* @param str
* @return
* @throws Exception
*/
public static String convertStrBase64Encode(String str) throws Exception {
if (!Strings.isNullOrEmpty(str)) {
str = Base64.encode(str, "utf-8");
}
return str;
}

/**
* 校验手机端特殊字符进行base64解码
*
* @param str
* @return
* @throws Exception
*/
public static String convertStr(String str) throws Exception {
if (!Strings.isNullOrEmpty(str)) {
str = Base64.decode(str, "utf-8");
}
return str;
}

/**
* 批量转换map中的value值base64解码
*
* @param map
* @param keys
* @return
* @throws Exception
*/
public static Map<String, Object> convertMap(Map<String, Object> map, String... keys) throws Exception {
for (String key : keys) {
String value = String.valueOf(map.get(key));
if (!Strings.isNullOrEmpty(value)) {
map.put(key, convertStr(value));
}
}
return map;
}