public class StringUtil {
/**
* 私有构造方法，防止类的实例化，因为工具类不需要实例化。
*/
private StringUtil() {
} private static final char[] digits = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
'U', 'V', 'W', 'X', 'Y', 'Z'}; /**
* 判断String是否为空
*
* @param str
* @return
*/
public static boolean isNull(String str) {
return (str == null || str.length() == 0);
} /**
* 判断String是否非空
*
* @param str
* @return
*/
public static boolean isNotNull(String str) {
return !isNull(str);
} /**
* 判断两个String是否相等。忽略大小写。
*
* @param str1
* @param str2
* @return
*/
public static boolean isEquals(String str1, String str2) {
return str1.equalsIgnoreCase(str2);
} /**
* 替换mainStrin中的所有oldString为newString，并返回替换后的String
*
* @param mainString 需要替换其中的某个子串的String
* @param oldString mainString中的要替换的String
* @param newString 替换oldString的String
* @return newString替换mainString中的oldString后的新String
*/
public static String replace(String mainString, String oldString,
String newString) {
if (mainString == null) {
return null;
}
if (oldString == null || oldString.length() == 0) {
return mainString;
}
if (newString == null) {
newString = "";
} int i = mainString.lastIndexOf(oldString);
if (i < 0) {
return mainString;
} StringBuffer mainSb = new StringBuffer(mainString);
while (i >= 0) {
mainSb.replace(i, i + oldString.length(), newString);
i = mainString.lastIndexOf(oldString, i - 1);
}
return mainSb.toString();
} /**
* @param mainString
* @param oldString
* @param newString
* @return
*/
public static String replaceFirst(String mainString, String oldString,
String newString) {
if (mainString == null) {
return null;
}
if (oldString == null || oldString.length() == 0) {
return mainString;
}
if (newString == null) {
newString = "";
} int i = mainString.lastIndexOf(oldString);
if (i < 0) {
return mainString;
} StringBuffer mainSb = new StringBuffer(mainString);
if (i >= 0) {
mainSb.replace(i, i + oldString.length(), newString);
}
return mainSb.toString();
} /**
* 连接List中的所有元素以创建一个String，其中List中的元素间以指定的delim来分隔
*
* @param list 需要连接的String为元素的List
* @param delim List中的元素的分隔符。(null表示直接连接list中的元素，不加入分割符)
* @return String 形式为：list的元素＋delim＋list的元素＋delim＋...
*/
public static String join(List list, String delim) {
if (list == null || list.size() < 1) {
return null;
}
StringBuffer buf = new StringBuffer();
Iterator i = list.iterator(); while (i.hasNext()) {
buf.append((String) i.next());
if (i.hasNext()) {
buf.append(delim);
}
}
return buf.toString();
} /**
* 将字符串数组使用指定的分隔符合并成一个字符串。
*
* @param array 字符串数组
* @param delim 分隔符，为null的时候使用""作为分隔符（即没有分隔符）
* @return 合并后的字符串
*/
public static String join(String[] array, String delim) {
int length = array.length - 1;
if (delim == null) {
delim = "";
}
StringBuffer result = new StringBuffer(length * 8);
for (int i = 0; i < length; i++) {
result.append(array[i]);
result.append(delim);
}
result.append(array[length]);
return result.toString();
} /**
* 以指定的delim分隔符分隔String，并将分隔的每一个String作为List的一个元素。
*
* @param str 需要分隔的string
* @param delim 分隔String的符合 (null表示以空格作为分隔符)
* @return 存储了分隔的子串的List
*/
public static List splitList(String str, String delim) {
List splitList = null;
StringTokenizer st = null; if (str == null) {
return splitList;
} if (delim != null) {
st = new StringTokenizer(str, delim);
} else {
st = new StringTokenizer(str);
}
if (st != null && st.hasMoreTokens()) {
splitList = new ArrayList(); while (st.hasMoreTokens()) {
splitList.add(st.nextToken());
}
}
return splitList;
} /**
* 此方法将给出的字符串source使用delim划分为单词数组。
*
* @param source 需要进行划分的原字符串
* @param delim 单词的分隔字符串
* @return 划分以后的数组，如果source为null的时候返回以source为唯一元素的数组，
* 如果delim为null则使用逗号作为分隔字符串。
*/
public static String[] split(String source, String delim) {
String[] wordLists;
if (source == null) {
wordLists = new String[1];
wordLists[0] = source;
return wordLists;
}
if (delim == null) {
delim = ",";
}
StringTokenizer st = new StringTokenizer(source, delim);
int total = st.countTokens();
wordLists = new String[total];
for (int i = 0; i < total; i++) {
wordLists[i] = st.nextToken();
}
return wordLists;
} /**
* 此方法将给出的字符串source使用delim划分为单词数组。
*
* @param source 需要进行划分的原字符串
* @param delim 单词的分隔字符
* @return 划分以后的数组，如果source为null的时候返回以source为唯一元素的数组。
*/
public static String[] split(String source, char delim) {
return split(source, String.valueOf(delim));
} /**
* 此方法将给出的字符串source使用逗号划分为单词数组。
*
* @param source 需要进行划分的原字符串
* @return 划分以后的数组，如果source为null的时候返回以source为唯一元素的数组。
*/
public static String[] split(String source) {
return split(source, ",");
} /**
* 转换成sql中IN类型的字符串
* 如: aaa,bbb,ccc,ddd,de
* 转换结果为：'aaa','bbb','ccc','ddd','de'
*
* @param source
* @param delim
* @return
*/
public static String ChangeToInsqlType(String source, String delim) {
String s = "";
String[] l = split(source, delim);
for (int k = 0; k < l.length; k++) {
s += "'" + l[k] + "'";
if (k != l.length - 1) s += ",";
}
return s;
} /**
* 从存储了name/value对的String中得到Map。并对其中的name和value进行Html的编码。
*
* @param str 转换为Map的String，String的形式为：name1=value1?name2=value2?...
* @return a Map 存储了name/value对
*/
public static Map strToMap(String str) {
if (str == null) {
return null;
}
Map decodedMap = new HashMap();
List elements = splitList(str, "?");
Iterator i = elements.iterator(); while (i.hasNext()) {
String s = (String) i.next();
List e = splitList(s, "=");
if (e.size() != 2) {
continue;
}
String name = (String) e.get(0);
String value = (String) e.get(1); decodedMap.put(URLDecoder.decode(name), URLDecoder.decode(value));
}
return decodedMap;
} /**
* 从Map中得到经过Html格式编码的String。注意：map的元素必须都是String。
*
* @param map 存储name/value对的Map
* @return String 经过Html格式编码的String：name1=value1?name2=value2?...
*/
public static String mapToStr(Map map) {
if (map == null) {
return null;
}
StringBuffer buf = new StringBuffer();
Set keySet = map.keySet();
Iterator i = keySet.iterator();
boolean first = true; while (i.hasNext()) {
Object key = i.next();
Object value = map.get(key); if (!(key instanceof String) || !(value instanceof String)) {
continue;
}
String encodedName = URLEncoder.encode((String) key);
String encodedValue = URLEncoder.encode((String) value); if (first) {
first = false;
} else {
buf.append("?");
}
buf.append(encodedName);
buf.append("=");
buf.append(encodedValue);
}
return buf.toString();
} /**
* 删除String中的所有空格，并返回删除后的String
*
* @param str 需要进行删除操作的String
* @return String 删除空格后的String
*/
public static String removeSpaces(String str) {
StringBuffer newString = new StringBuffer();
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) != ' ') {
newString.append(str.charAt(i));
}
}
return newString.toString();
} /**
* 判断一个String里是不是包含另一个String
*
* @param MainString
* @param containedString
* @return
*/
public static boolean contains(String MainString, String containedString) {
int i = MainString.indexOf(containedString);
if (i == -1) {
return false;
} else {
return true;
}
} /**
* 字符串数组中是否包含指定的字符串。
*
* @param caseSensitive 是否大小写敏感
* @return 包含时返回true，否则返回false
*/
public static int contains(String[] mainStrings, String containedString,
boolean caseSensitive) {
for (int i = 0; i < mainStrings.length; i++) {
if (caseSensitive == true) {
if (mainStrings[i].equals(containedString)) {
return i;
}
} else {
if (mainStrings[i].equalsIgnoreCase(containedString)) {
return i;
}
}
}
return -1;
} /**
* 切取字符串
*
* @param srcString
* @param key
* @param length
* @return
*/
public static String getString(String srcString, String key, int length, String postfix) {
if (srcString == null || srcString.trim().length() == 0) return "";
String returnStr = "";
int index = srcString.indexOf(key);
if (index > 0) {
returnStr = srcString.substring(0, index) + postfix;
} else {
if (srcString.length() > length) {
returnStr = srcString.substring(0, length) + postfix;
} else {
returnStr = srcString;
}
}
returnStr = returnStr.replaceAll("<P>", "");
returnStr = returnStr.replaceAll("<p>", "");
returnStr = returnStr.replaceAll("</P>", "");
returnStr = returnStr.replaceAll("</p>", "");
returnStr = returnStr.replaceAll("<BR>", "");
returnStr = returnStr.replaceAll("<br>", "");
return returnStr;
} /**
* 字符串数组中是否包含指定的字符串。大小写敏感。
*
* @return 包含时返回true，否则返回false
*/
public static int contains(String[] mainStrings, String containedString) {
return contains(mainStrings, containedString, true);
} /**
* 不区分大小写判定字符串数组中是否包含指定的字符串。
*
* @return 包含时返回true，否则返回false
*/
public static int containsIgnoreCase(String[] mainStrings,
String containedString) {
return contains(mainStrings, containedString, false);
} /**
* 产生制定长度的随机字符串.
* <p>所产生的字符串包括从0到九这些数字及26个大写英文字母.
*
* @param length 所需字符串的长度，整数。
* @return 字符串
*/
public static String getRandomString(int length) {
int temp;
String strRnd = "";
for (int i = 0; i < length; i++) {
temp = (new Double(Math.random() * 997))
.intValue() % digits.length;
strRnd += String.valueOf(digits[temp]);
}
return strRnd;
} /**
* 将一个字符串进行中文处理.
* <p>解决由编码原因产生的中文乱码问题.
*
* @param str 输入字符串
* @return 输出转换后的字符串，如果出错，返回null。
*/
public static String toChinese(String str) {
try {
if (str == null) {
return null;
} else {
str = new String(str.getBytes("ISO8859_1"), "GBK");
return str;
}
} catch (Exception e) {
System.err.println(e.getMessage());
return null;
}
} /**
* 将一个字符串进行中文处理.
* <p>解决由编码原因产生的中文乱码问题.
*
* @param str 输入字符串
* @return 输出转换后的字符串，如果出错，返回null。
*/
public static String toUTF(String str) {
try {
if (str == null) {
return null;
} else {
str = new String(str.getBytes("GB2312"), "GB2312");
return str;
}
} catch (Exception e) {
System.err.println(e.getMessage());
return null;
}
} public static String toUtf8String(String s) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c >= 0 && c <= 255) {
sb.append(c);
} else {
byte[] b;
try {
b = Character.toString(c).getBytes("utf-8");
} catch (Exception ex) {
System.out.println(ex);
b = new byte[0];
}
for (int j = 0; j < b.length; j++) {
int k = b[j];
if (k < 0) k += 256;
sb.append("%" + Integer.toHexString(k).
toUpperCase());
}
}
}
return sb.toString();
} public static String UnicodeToGB(String strIn) {
byte[] b;
String strOut = null;
if (strIn == null || (strIn.trim()).equals(""))
return strIn;
try {
b = strIn.getBytes("GB2312");
strOut = new String(b, "ISO8859_1");
} catch (Exception e) {
System.out.println("unicodeToGB exception : " + e.getMessage() + "\n");
}
return strOut;
} public static String GBToUnicode(String strIn) {
byte[] b;
String strOut = null;
if (strIn == null || (strIn.trim()).equals(""))
return strIn;
try {
b = strIn.getBytes("ISO8859_1");
strOut = new String(b, "GB2312");
} catch (Exception e) {
System.out.println("GBToUnicode exception : " + e.getMessage() + "\n");
}
return strOut;
} /**
* 将一个字符串进行中文处理.
* <p>解决中文名不能下载的问题.
*
* @return 输出转换后的字符串，如果出错，返回null。
*/
public static String transCode(String value, String enc) {
try {
if (value == null) {
return null;
} else {
value = value.trim();
value = new String(value.getBytes("ISO8859_1"), enc);
return value;
}
} catch (Exception e) {
return null;
}
} /**
* 将阿拉伯数字转换为中文大写数字.
* 注意：该方法为临时使用，对0支持不好.
* 例如：100将转换为一百零十零.
*
* @param number 阿拉伯数字
* @return 中文大写数字
*/
public static String toChineseNumber(String number) {
String[] num = {
"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};
String[] unt = {
"", "", "十", "百", "千", "万"};
String value = "";
for (int i = 0, j = number.length(); i < number.length(); j--, i++) {
value += num[Integer.parseInt(String.valueOf(number.charAt(i)))] +
unt[j];
}
value = value + number.substring(number.length());
if (value.substring(0, 1) == "一" && value.length() == 3) {
value = value.substring(1, value.length());
}
return value;
} /**
* 将阿拉伯数字转换为中文大写数字
*
* @param number 阿拉伯数字
* @return 中文大写数字
*/
public static String toChineseNumber(int number) {
return toChineseNumber(String.valueOf(number));
} /**
* 循环打印字符串数组。
* 字符串数组的各元素间以指定字符分隔，
* 如果字符串中已经包含指定字符则在字符串的两端加上双引号。
*
* @param strings 字符串数组
* @param delim 分隔符
* @param out 打印到的输出流
*/
public static void printStrings(String[] strings, String delim,
OutputStream out) {
try {
if (strings != null) {
int length = strings.length - 1;
for (int i = 0; i < length; i++) {
if (strings[i] != null) {
if (strings[i].indexOf(delim) > -1) {
out.write(("\"" + strings[i] + "\"" + delim).
getBytes());
} else {
out.write((strings[i] + delim).getBytes());
}
} else {
out.write("null".getBytes());
}
}
if (strings[length] != null) {
if (strings[length].indexOf(delim) > -1) {
out.write(("\"" + strings[length] + "\"").getBytes());
} else {
out.write(strings[length].getBytes());
}
} else {
out.write("null".getBytes());
}
} else {
out.write("null".getBytes());
}
} catch (IOException e) { }
} /**
* 循环打印字符串数组到标准输出。
* 字符串数组的各元素间以指定字符分隔，如果字符串中已经包含指定字符则在字符串的两端加上双引号。
*
* @param strings 字符串数组
* @param delim 分隔符
*/
public static void printStrings(String[] strings, String delim) {
printStrings(strings, delim, System.out);
} /**
* 循环打印字符串数组。
* 字符串数组的各元素间以逗号分隔，如果字符串中已经包含逗号则在字符串的两端加上双引号。
*
* @param strings 字符串数组
* @param out 打印到的输出流
*/
public static void printStrings(String[] strings, OutputStream out) {
printStrings(strings, ",", out);
} /**
* 循环打印字符串数组到系统标准输出流System.out。
* 字符串数组的各元素间以逗号分隔，如果字符串中已经包含逗号则在字符串的两端加上双引号。
*
* @param strings 字符串数组
*/
public static void printStrings(String[] strings) {
printStrings(strings, ",", System.out);
} /**
* (解决了一些空格全角占两位置的问题)
* 取得显示的字符长度，英文，数字占一个位置，汉字占两个位置
*
* @param str
* @return
*/
public static int getStringLength(String str) {
/** int reInt = 0;
char[] tempChar = str.toCharArray();
for (int kk = 0; kk < tempChar.length; kk++) {
String s1 = str.valueOf(tempChar[kk]);
byte[] b = s1.getBytes();
reInt += b.length;
}
return reInt; **/
return str.length();
} /**
* 判断是否为NULL
*
* @param str
* @return
*/
public static String getString(String str) {
if (str == null)
return "";
else
return str;
} /**
* 判断是否为NULL
*
* @param str
* @return
*/
public static String getString(String str, String defValue) {
if (str == null || "".equals(str) || "null".equals(str) || "NULL".equals(str))
return defValue;
else
return str;
} /**
* 判断是否为NULL
*
* @param str
* @return
*/
public static String getString(Object str, String defValue) {
return getString(String.valueOf(str), defValue);
} /**
* 取字符串的前toCount个字符
*
* @param str
* @param count1
* @return
*/
public static String substring(String str, int count1) {
int count = count1 / 2;
/** int i = 0;
String s = "";
if (str == null) return "";
char[] tempChar = str.toCharArray();
for (int kk = 0; (kk < tempChar.length && count > i); kk++) {
String s1 = str.valueOf(tempChar[kk]);
byte[] b = s1.getBytes();
i += b.length;
s += tempChar[kk];
}
if (count == i || (count == i - 1)) s += "..";
return s; **/
if (str == null) return "";
if (str.length() < count)
return str;
else
return str.substring(0, count) + "..";
} /**
* 将字符串转换为整型数
*
* @param str
* @param defaultValue
* @return
*/
public static int getInt(String str, int defaultValue) {
int returnInt = defaultValue; try {
returnInt = Integer.parseInt(str);
} catch (Exception e) {
returnInt = defaultValue;
}
return returnInt;
} /**
* 将字符串转换为整型数
*
* @param str
* @param defaultValue
* @return
*/
public static long getLong(String str, long defaultValue) {
long returnInt = defaultValue;
try {
returnInt = Long.parseLong(str);
} catch (Exception e) {
returnInt = defaultValue;
}
return returnInt;
} /**
* 将字符串转换为整型数
*
* @param str
* @param defaultValue
* @return
*/
public static double getDouble(String str, double defaultValue) {
double returnInt = defaultValue;
try {
returnInt = Double.parseDouble(str);
} catch (Exception e) {
returnInt = defaultValue;
}
return returnInt;
} /**
* 判断字符串是否以指定字符串开始，
*
* @param sourceString
* @param keyString
* @return
*/
public static boolean isBeginWith(String sourceString, String keyString) {
int index = sourceString.indexOf(keyString);
if (index == 0)
return true;
else
return false;
} /**
* 判断字符串是否以指定字符串结束，
*
* @param sourceString
* @param keyString
* @return
*/
public static boolean isEndWith(String sourceString, String keyString) {
int index = sourceString.lastIndexOf(keyString);
if (index == sourceString.length() - keyString.length())
return true;
else
return false;
} /**
* 根据流取得字符串，用于clob
*
* @param cl
* @return
* @throws HibernateException
* @throws SQLException
*/
public static String getClobString(java.sql.Clob cl)
throws HibernateException, SQLException {
if (cl == null) return "";
Reader clobReader = cl.getCharacterStream();
if (clobReader == null) {
return null;
} String str = new String();
BufferedReader bufferedClobReader = new BufferedReader(clobReader);
try {
String line = null;
while ((line = bufferedClobReader.readLine()) != null) {
str += line;
}
bufferedClobReader.close();
} catch (IOException e) {
throw new SQLException(e.toString());
} return str;
} /**
* 返回文件大小
* 如果大于1MB，则以MB为单位，返回两位小数单位
* 如果大小1KB，则以KB为单位，返回整数，
* 如果小于1KB，则以Byte为单位
*
* @param fileSize
* @return
*/
public static String getFileSize(int fileSize) {
return getFileSize((long) fileSize);
} /**
* 返回文件大小
* 如果大于1MB，则以MB为单位，返回两位小数单位
* 如果大小1KB，则以KB为单位，返回整数，
* 如果小于1KB，则以Byte为单位
*
* @param fileSize
* @return
*/
public static String getFileSize(long fileSize) {
String reStr = "";
long Igb, Imb = 0, temp = 0, Ikb = 0, Ib = 0;
if (fileSize > 1024 * 1024 * 1024) {
Igb = fileSize / (1024 * 1024 * 1024);
temp = (fileSize % (1024 * 1024 * 1024)) * 100 / (1024 * 1024 * 1024);
reStr = Igb + "." + temp + "GB";
} else if (fileSize > 1024 * 1024) {
Imb = fileSize / (1024 * 1024);
temp = (fileSize % (1024 * 1024)) * 100 / (1024 * 1024);
reStr = Imb + "." + temp + "MB";
} else if (fileSize > 1024) {
Ikb = fileSize / 1024;
reStr = Ikb + "KB";
} else {
Ib = fileSize;
reStr = Ib + "字节";
}
return reStr;
} /**
* 取得文件后缀等用
* 如aaaa.txt
* 返回txt
*
* @param source
* @param key
* @return
*/
public static String getLastIndexOfString(String source, String key) {
int k = source.lastIndexOf(key);
return source.substring(k + 1, source.length());
} /**
* 追加字符串
*
* @param str1 原字符串
* @param str2 要追加的字符串
* @param count 总位数
* @param right 方向，true是向右，false是向左
* @return 追加后的字符串
*/
public static String AppendStr(String str1, String str2, int count, boolean right) {
String newStr = "";
for (int i = 0; i < (count - str1.length()); i++)
newStr += str2;
if (right)
return str1 + newStr;
else
return newStr + str1;
} /**
* 将字符串中的变量（以“%”为前导后接数字）使用values数组中的内容进行替换。
* 替换的过程是不进行嵌套的，即如果替换的内容中包含变量表达式时不会替换。
*
* @param source 带参数的原字符串
* @param values 替换用的字符串数组
* @return 替换后的字符串
*/
public static String getReplaceString(String source, String[] values) {
return getReplaceString("%", source, values);
} /**
* 将字符串中的变量使用values数组中的内容进行替换。
* 替换的过程是不进行嵌套的，即如果替换的内容中包含变量表达式时不会替换。
*
* @param prefix 变量前缀字符串
* @param source 带参数的原字符串
* @param values 替换用的字符串数组
* @return 替换后的字符串。
* 如果前缀为null则使用“%”作为前缀；
* 如果source或者values为null或者values的长度为0则返回source；
* 如果values的长度大于参数的个数，多余的值将被忽略；
* 如果values的长度小于参数的个数，则后面的所有参数都使用最后一个值进行替换。
*/
public static String getReplaceString(String prefix, String source,
String[] values) {
String result = source;
if (source == null || values == null || values.length < 1) {
return source;
}
if (prefix == null) {
prefix = "%";
} for (int i = 0; i < values.length; i++) {
String argument = prefix + Integer.toString(i + 1);
int index = result.indexOf(argument);
if (index != -1) {
String temp = result.substring(0, index);
if (i < values.length) {
temp += values[i];
} else {
temp += values[values.length - 1];
}
temp += result.substring(index + 2);
result = temp;
}
}
return result;
} /**
* 过滤系统错误
*
* @param e
* @param filterPackages
* @return
* @throws IOException
*/
public static String filterStackTrace(Throwable e, String filterPackages[])
throws IOException {
if (e == null) return "No exception founded";
StringWriter expout = new StringWriter();
StringBuffer out = new StringBuffer();
e.printStackTrace(new PrintWriter(expout));
BufferedReader br = new BufferedReader(new StringReader(expout.toString()));
String s1;
while ((s1 = br.readLine()) != null) {
boolean f = false;
for (int i = 0; i < filterPackages.length; i++) {
if (s1.indexOf(filterPackages[i]) == -1)
continue;
f = true;
break;
}
if (!f) {
out.append(s1);
out.append("\n");
}
}
return out.toString();
} /**
* @param main
* @param s
* @return
*/
public static String toString(String[] main, String s) {
if (main == null || main.length == 0) return "";
String returnStr = s;
for (int i = 0; i < main.length; i++) {
returnStr += main[i] + s;
}
return returnStr;
} /**
* 取得星期大写
*
* @param i
* @return
*/
public static String getWeekStr(int i) {
String[] s = new String[]{"星期日", "星期一", "星期二",
"星期三", "星期四", "星期五", "星期六"};
return s[i];
} /**
* @return
*/
public static String trim(String s) {
if (s == null) s = "";
return s.trim();
} /**
* 去掉首尾字符
*
* @param str
* @param ts
* @return
*/
public static String trimBeginEnd(String str, String ts) {
if (str == null) return "";
while (str.startsWith(ts)) str = str.substring(ts.length(), str.length());
while (str.endsWith(ts)) str = str.substring(0, str.length() - ts.length());
return str;
} /**
* 去掉首尾空格，包括全角，半角
*
* @param s
* @return
*/
public static String trimBeginEndBlank(String s) {
if (s == null) return "";
s = s.trim();
s = StringUtil.trimBeginEnd(s, " ");
s = StringUtil.trimBeginEnd(s, " ");
return s;
} public static void main(String[] arg) {
String s = "ddddsafdasdfddd", ts = "dd";
System.out.println(StringUtil.trimBeginEnd(s, ts));
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
