package com.sun.util;
import java.io.File;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.MessageDigest;
import java.sql.Timestamp;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 字符串操作通用類
*
* @author sunjun
* @version v5.0
*/
public class StringUtil {
// 字符串常量枚舉
public static enum REGEX_ENUM {
EMAIL("^\\w+([-+.']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$"), CHINESE_CHARACTER(
"[\\u4E00-\\u9FA5]+");
private String value;
private REGEX_ENUM(String value) {
this.value = value;
}
public String toString() {
return this.value;
}
};
/**
* 檢查字符串str是否匹配正則表達式regex
*
* @param regex
* @param str
* @return
*/
public static boolean matcherRegex(String regex, String str) {
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
return matcher.matches();
}
/**
* 是否為漢字
*
* @param ch
* @return
*/
public static boolean isChineseCharacter(char ch) {
return matcherRegex(REGEX_ENUM.CHINESE_CHARACTER.toString(), String
.valueOf(ch));
}
/**
* 按字節(jié)截取字符串
*
* @param str
* 要截取的字符串
* @param byteLength
* 長度
* @return 結(jié)果字符串
*/
public static String subString(String str, int byteLength) {
if (isBlank(str))
return "";
if (str.getBytes().length <= byteLength)
return str;
if (str.length() >= byteLength)
str = str.substring(0, byteLength);
int readLen = 0;
String c = null;
StringBuffer sb = new StringBuffer("");
for (int i = 0; i < str.length(); i++) {
c = String.valueOf(str.charAt(i));
readLen += c.getBytes().length;
if (readLen > byteLength)
return sb.toString();
sb.append(c);
}
return sb.toString();
}
/**
* 檢查字符串長度是否在指定長度范圍內(nèi)(minLength<=str.length<=maxLength)
*
* @param str
* 要檢查的字符串
* @param minLength
* 最小長度
* @param maxLength
* 最大長度
* @return boolean 字符串長度在指定長度范圍內(nèi)返回true，否則返回false
*/
public static boolean checkLength(String str, int minLength, int maxLength) {
if (isBlank(str))
return false;
int len = str.length();
if (minLength == 0)
return len <= maxLength;
else if (maxLength == 0)
return len >= minLength;
else
return (len >= minLength && len <= maxLength);
}
/**
* 按UTF-8編碼來解碼字符串
*
* @param str
* 要解碼的字符串
* @return String 解碼str后字符串
*/
public static String decodeString(String str) {
return decodeString(str, "UTF-8");
}
/**
* 按指定編碼來解碼字符串
*
* @param str
* @param encoding
* @return
*/
public static String decodeString(String str, String encoding) {
if (isBlank(str))
return "";
try {
return URLDecoder.decode(str.trim(), encoding);
} catch (UnsupportedEncodingException e) {
}
return "";
}
/**
* 按指定編碼來解碼字符串
*
* @param str
* @param encoding
* @return
*/
public static String decodeURI(String str) {
if (isBlank(str))
return "";
try {
return new String(str.getBytes("ISO8859-1"), "UTF-8");
} catch (UnsupportedEncodingException e) {
}
return "";
}
/**
* 按UTF-8編碼來編碼字符串
*
* @param str
* 要編碼的字符串
* @return String 編碼str后字符串
*/
public static String encodeString(String str) {
return encodeString(str, "UTF-8");
}
/**
* 按UTF-8編碼來編碼字符串
*
* @param str
* 要編碼的字符串
* @return String 編碼str后字符串
*/
public static String encodeString(String str, String encoding) {
if (isBlank(str))
return "";
try {
return URLEncoder.encode(str.trim(), encoding);
} catch (UnsupportedEncodingException e) {
}
return "";
}
/**
* 根據(jù)時間得到唯一字符串
*
* @return
*/
public static String getOnlyString() {
return String.valueOf(System.currentTimeMillis());
}
/**
* 檢查對象obj是否為空
*
* @param str
* 要檢查的字符串
* @return boolean str為空返回true，否則返回false
*/
public static boolean isBlank(Object obj) {
if (obj == null)
return true;
if (obj instanceof String && obj.toString().trim().length() == 0)
return true;
return false;
}
/**
* 檢查字符串str是否為整型
*
* @param str
* 要檢查的字符串
* @return boolean str為整型返回true，否則返回false
*/
public static boolean isInteger(String str) {
if (isBlank(str))
return false;
try {
Integer.parseInt(str.trim());
return true;
} catch (Exception e) {
}
return false;
}
/**
* 檢查字符串str是否為長整型
*
* @param str
* 要檢查的字符串
* @return boolean str為長整型返回true，否則返回false
*/
public static boolean isLong(String str) {
if (isBlank(str))
return false;
try {
Long.parseLong(str.trim());
return true;
} catch (Exception e) {
}
return false;
}
/**
* 檢查字符串str是否為布爾型
*
* @param str
* 要檢查的字符串
* @return boolean str為布爾型返回true，否則返回false
*/
public static boolean isBoolean(String str) {
if (isBlank(str))
return false;
try {
Boolean.parseBoolean(str.trim());
return true;
} catch (Exception e) {
}
return false;
}
/**
* 檢查字符串str是否為double類型
*
* @param str
* @return
*/
public static boolean isDouble(String str) {
if (isBlank(str))
return false;
try {
Double.parseDouble(str.trim());
return true;
} catch (Exception e) {
}
return false;
}
/**
* 檢查字符串str是否為時間型
*
* @param str
* 要檢查的字符串
* @return boolean str為時間型返回true，否則返回false
*/
public static boolean isDate(String str) {
if (isBlank(str))
return false;
try {
java.sql.Date sqlDate = java.sql.Date.valueOf(str.trim());
return true;
} catch (Exception e) {
}
return false;
}
/**
* 檢查對象數(shù)組strings的每個元素是否為空
*
* @param objs
* 要檢查的對象數(shù)組
* @return boolean objs數(shù)組元素為空返回true，否則返回false
*/
public static boolean isBlanks(Object... objs) {
for (Object obj : objs) {
if (StringUtil.isBlank(obj))
return true;
}
return false;
}
/**
* 檢查字符串?dāng)?shù)組str是否為長整型數(shù)組
*
* @param str
* 要檢查的字符串
* @return boolean str為長整型數(shù)組返回true，否則返回false
*/
public static boolean isLongs(String str[]) {
for (int i = 0; i < str.length; i++) {
if (!isLong(str[i]))
return false;
}
return true;
}
/**
* 檢查字符串?dāng)?shù)組str是否為整型數(shù)組
*
* @param str
* 要檢查的字符串
* @return boolean str為整型數(shù)組返回true，否則返回false
*/
public static boolean isIntegers(String str[]) {
for (int i = 0; i < str.length; i++)
if (!isInteger(str[i]))
return false;
return true;
}
/**
* 檢查字符串?dāng)?shù)組str是否為布爾型數(shù)組
*
* @param str
* 要檢查的字符串
* @return boolean str為布爾型數(shù)組返回true，否則返回false
*/
public static boolean isBooleans(String str[]) {
for (int i = 0; i < str.length; i++)
if (!isBoolean(str[i]))
return false;
return true;
}
/**
* 檢查字符串str是否為時間
*
* @param str
* 要檢查的字符串
* @return str為時間型返回true，否則返回false
*/
public static boolean isTimestamp(String str) {
if (isBlank(str))
return false;
try {
java.sql.Date d = java.sql.Date.valueOf(str.trim());
return true;
} catch (Exception ex) {
}
return false;
}
/**
* 檢查字符串str是否為(yyyy-MM-dd HH:mm:ss)模式的時間
*
* @param str
* 要檢查的字符串
* @return str為時間型返回true，否則返回false
*/
public static boolean isFullTimestamp(String str) {
if (isBlank(str))
return false;
try {
SimpleDateFormat format = new SimpleDateFormat(
"yyyy-MM-dd HH:mm:ss");
Date date = format.parse(str.trim());
return date != null;
} catch (Exception e) {
}
return false;
}
/**
* 將字符數(shù)組轉(zhuǎn)換為長整型數(shù)組
*
* @param str
* 字符數(shù)組
* @return Long[] 長整型數(shù)組
*/
public static Long[] stringsToLongs(String str[]) {
Long lon[] = new Long[str.length];
for (int i = 0; i < lon.length; i++)
lon[i] = new Long(str[i]);
return lon;
}
/**
* 將字符數(shù)組轉(zhuǎn)換為整型數(shù)組
*
* @param str
* 字符數(shù)組
* @return Integer[] 整型數(shù)組
*/
public static Integer[] stringsToIntegers(String str[]) {
Integer array[] = new Integer[str.length];
for (int i = 0; i < array.length; i++)
array[i] = new Integer(str[i]);
return array;
}
/**
* 將字符數(shù)組轉(zhuǎn)換為布爾型數(shù)組
*
* @param str
* 字符數(shù)組
* @return Boolean[] 布爾型數(shù)組
*/
public static Boolean[] stringsToBooleans(String str[]) {
Boolean array[] = new Boolean[str.length];
for (int i = 0; i < array.length; i++)
array[i] = new Boolean(str[i]);
return array;
}
/**
* 將字符數(shù)組轉(zhuǎn)換為浮點型數(shù)組
*
* @param str
* 字符數(shù)組
* @return double[] 浮點型數(shù)組
*/
public static double[] stringsToDoubles(String str[]) {
double array[] = new double[str.length];
for (int i = 0; i < array.length; i++)
array[i] = Double.parseDouble(str[i]);
return array;
}
/**
* 根據(jù)指定時間和格式字符串得到時間格式字符串
*
* @param d
* 時間
* @param pattern
* 格式字符串
* @return String 時間格式字符串
*/
public static String formatDate(Date d, String pattern) {
if (isBlank(d))
return "";
SimpleDateFormat format = new SimpleDateFormat(
isBlank(pattern) ? "yyyy-MM-dd HH-mm-ss" : pattern);
return format.format(d);
}
/**
* 根據(jù)時間字符串得到時間(yyyy-MM-dd)
*
* @param str
* 時間字符串
* @return Timestamp 時間
*/
public static Timestamp getTimestamp(String str) {
try {
Date d = java.sql.Date.valueOf(str.trim());
return new Timestamp(d.getTime());
} catch (Exception ex) {
}
return null;
}
/**
* 根據(jù)時間字符串得到(yyyy-MM-dd HH-mm-ss)格式時間
*
* @param str
* 時間字符串
* @return Timestamp 時間
*/
public static Timestamp getFullTimestamp(String str) {
try {
SimpleDateFormat format = new SimpleDateFormat(
"yyyy-MM-dd HH:mm:ss");
Date date = format.parse(str.trim());
return new Timestamp(date.getTime());
} catch (Exception ex) {
}
return null;
}
/**
* 得到數(shù)字格式化后的字符串
*
* @param number
* Number類型
* @param minFractionDigits
* 小數(shù)最小位數(shù)
* @param maxFractionDigits
* 小數(shù)最大位數(shù)
* @return String 格式化后的字符串
*/
public static String formatNumber(Number number, int minFractionDigits,
int maxFractionDigits) {
NumberFormat format = NumberFormat.getInstance();
format.setMinimumFractionDigits(minFractionDigits);
format.setMaximumFractionDigits(maxFractionDigits);
return format.format(number);
}
/**
* 字符串高亮<br>
* 解決了高亮前綴或高亮后綴在要高亮顯示的字符串?dāng)?shù)組在存在時的問題，根據(jù)本算法可解決JS高亮顯示時相同的問題
*
* @param text
* 內(nèi)容
* @param replaceStrs
* 要高亮顯示的字符串?dāng)?shù)組
* @param beginStr
* 高亮前綴，如<font color=red>
* @param endStr
* 高亮后綴，如</font>
* @return
*/
public static String heightLight(String text, String[] replaceStrs,
String beginStr, String endStr) {
if (text.length() == 0)
return text;
StringBuilder str = new StringBuilder();
for (int i = 0; i < replaceStrs.length; i++) {
String replaceStr = replaceStrs[i];
int index = text.indexOf(replaceStr);
if (index >= 0) {
String afterStr = null;
if (index > 0) {
String beforeStr = text.substring(0, index);
afterStr = text.substring(index + replaceStr.length());
str.append(heightLight(beforeStr, replaceStrs, beginStr,
endStr));
} else
afterStr = text.substring(replaceStr.length());
str.append(beginStr).append(replaceStr).append(endStr);
str
.append(heightLight(afterStr, replaceStrs, beginStr,
endStr));
break;
}
}
if (str.length() == 0)
return text;
return str.toString();
}
/**
* 替換指定的字符串?dāng)?shù)組為一個字符串<br>
* 速度比String.replaceAll快3倍左右，比apache-common StringUtils.replace快2倍左右
*
* @param text
* @param replaceStrs
* @param newStr
* @return
*/
public static String replaceAll(String text, String[] replaceStrs,
String newStr) {
if (text.length() == 0)
return text;
StringBuilder str = new StringBuilder();
for (int i = 0; i < replaceStrs.length; i++) {
String replaceStr = replaceStrs[i];
int index = text.indexOf(replaceStr);
if (index >= 0) {
String afterStr = null;
if (index > 0) {
String beforeStr = text.substring(0, index);
afterStr = text.substring(index + replaceStr.length());
str.append(replaceAll(beforeStr, replaceStrs, newStr));
} else
afterStr = text.substring(replaceStr.length());
str.append(newStr);
str.append(replaceAll(afterStr, replaceStrs, newStr));
break;
}
}
if (str.length() == 0)
return text;
return str.toString();
}
/**
* 替換指定的字符串為一個字符串<br>
* 速度比String.replaceAll快3倍左右，比apache-common StringUtils.replace快2倍左右
*
* @param text
* @param replaceStr
* @param newStr
* @return
*/
public static String replaceAll(String text, String replaceStr,
String newStr) {
if (text.length() == 0)
return text;
StringBuilder str = new StringBuilder();
int index = text.indexOf(replaceStr);
if (index >= 0) {
String afterStr = null;
if (index > 0) {
String beforeStr = text.substring(0, index);
afterStr = text.substring(index + replaceStr.length());
str.append(replaceAll(beforeStr, replaceStr, newStr));
} else
afterStr = text.substring(replaceStr.length());
str.append(newStr);
str.append(replaceAll(afterStr, replaceStr, newStr));
}
if (str.length() == 0)
return text;
return str.toString();
}
/**
* 替換指定的字符串?dāng)?shù)組為一個字符串?dāng)?shù)組<br>
* 速度比String.replaceAll快3倍左右，比apache-common StringUtils.replace快2倍左右
*
* @param text
* @param replaceStrs
* @param newStrs
* @return
*/
public static String replaceAllArray(String text, String[] replaceStrs,
String[] newStrs) {
if (text.length() == 0)
return text;
StringBuilder str = new StringBuilder();
for (int i = 0; i < replaceStrs.length; i++) {
String replaceStr = replaceStrs[i];
int index = text.indexOf(replaceStr);
if (index >= 0) {
String afterStr = null;
if (index > 0) {
String beforeStr = text.substring(0, index);
afterStr = text.substring(index + replaceStr.length());
str
.append(replaceAllArray(beforeStr, replaceStrs,
newStrs));
} else
afterStr = text.substring(replaceStr.length());
str.append(newStrs[i]);
str.append(replaceAllArray(afterStr, replaceStrs, newStrs));
break;
}
}
if (str.length() == 0)
return text;
return str.toString();
}
/**
* 解碼HTML(將>,<,",&轉(zhuǎn)換成>,<,",& )
*
* @param html
* @return
*/
public static String decodeHTML(String html) {
if (isBlank(html))
return "";
String[] replaceStr = { "&", "<", ">", """ };
String[] newStr = { "&", "<", ">", "\"" };
return replaceAllArray(html, replaceStr, newStr);
}
/**
* 編碼HTML(將>,<,",&
* 轉(zhuǎn)換成>,<,",&)(高效率，來自FreeMarker模板源碼，比replaceAll速度快很多)
*
* @param html
* @return
*/
public static String encodeHTML(String html) {
if (isBlank(html))
return "";
int ln = html.length();
char c;
StringBuffer b;
for (int i = 0; i < ln; i++) {
c = html.charAt(i);
if (c == '<' || c == '>' || c == '&' || c == '"') {
b = new StringBuffer(html.substring(0, i));
switch (c) {
case '<':
b.append("<");
break;
case '>':
b.append(">");
break;
case '&':
b.append("&");
break;
case '"':
b.append(""");
break;
}
i++;
int next = i;
while (i < ln) {
c = html.charAt(i);
if (c == '<' || c == '>' || c == '&' || c == '"') {
b.append(html.substring(next, i));
switch (c) {
case '<':
b.append("<");
break;
case '>':
b.append(">");
break;
case '&':
b.append("&");
break;
case '"':
b.append(""");
break;
}
next = i + 1;
}
i++;
}
if (next < ln)
b.append(html.substring(next));
html = b.toString();
break;
}
}
return html;
}
/**
* MD5加密
*
* @param plainText
* 要加密的字符串
* @return 加密后的字符串
*/
public static String Md5(String plainText) {
StringBuffer buf = new StringBuffer("");
try {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(plainText.getBytes());
byte b[] = md.digest();
int i = 0;
for (int offset = 0; offset < b.length; offset++) {
i = b[offset];
if (i < 0)
i += 256;
if (i < 16)
buf.append("0");
buf.append(Integer.toHexString(i));
}
} catch (Exception e) {
e.printStackTrace();
}
return buf.toString();
}
/**
* MD5加密(32)
*
* @param plainText
* 要加密的字符串
* @return
*/
public final static String MD5(String plainText) {
char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f' };
try {
byte[] strTemp = plainText.getBytes();
MessageDigest mdTemp = MessageDigest.getInstance("MD5");
mdTemp.update(strTemp);
byte[] md = mdTemp.digest();
int j = md.length;
char str[] = new char[j * 2];
int k = 0;
for (int i = 0; i < j; i++) {
byte byte0 = md[i];
str[k++] = hexDigits[byte0 >>> 4 & 0xf];
str[k++] = hexDigits[byte0 & 0xf];
}
return new String(str);
} catch (Exception e) {
}
return "";
}
}