import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.sxd.da.base.exception.UncheckedException;
/**
* 字符串工具類。
*/
public abstract class StringUtils {
/**
* 判斷指定字符串是否爲空。
*
* @param str
* 待判斷的字符串
* @return 返回指定字符串是否爲空。
*/
public static Boolean isEmpty(String str) {
return str == null || str.isEmpty();
}
/**
* 判斷指定字符串是否不爲空。
*
* @param str
* 待判斷的字符串
* @return 返回指定字符串是否不爲空。
*/
public static Boolean isNotEmpty(String str) {
return !isEmpty(str);
}
/**
* 判斷指定字符串是否爲空字符串。
*
* @param str
* 待判斷的字符串
* @return 返回指定字符串是否爲空字符串。
*/
public static Boolean isBlank(String str) {
if (isEmpty(str)) {
return true;
}
for (char c : str.toCharArray()) {
if (!Character.isWhitespace(c)) {
return false;
}
}
return true;
}
/**
* 判斷指定字符串是否不爲空字符串。
*
* @param str
* 待判斷的字符串
* @return 返回指定字符串是否不爲空字符串。
*/
public static Boolean isNotBlank(String str) {
return !isBlank(str);
}
/**
* 截取指定分隔符前的字符串內容。
*
* @param str
* 待截取的字符串
* @param separator
* 分隔符
* @return 返回指定分隔符前的字符串內容。
*/
public static String substringBefore(String str, String separator) {
Assert.notEmpty(str);
Assert.notEmpty(separator);
int pos = str.indexOf(separator);
if (pos == -1) {
return str;
}
return str.substring(0, pos);
}
/**
* 截取最後一個分隔符前的字符串內容。
*
* @param str
* 待截取的字符串
* @param separator
* 分隔符
* @return 返回最後一個分隔符前的字符串內容。
*/
public static String substringBeforeLast(String str, String separator) {
Assert.notEmpty(str);
Assert.notEmpty(separator);
int pos = str.lastIndexOf(separator);
if (pos == -1) {
return str;
}
return str.substring(0, pos);
}
/**
* 截取指定分隔符後的字符串內容。
*
* @param str
* 待截取的字符串
* @param separator
* 分隔符
* @return 返回指定分隔符後的字符串內容。
*/
public static String substringAfter(String str, String separator) {
Assert.notEmpty(str);
Assert.notEmpty(separator);
int pos = str.indexOf(separator);
if (pos == -1) {
return "";
}
return str.substring(pos + separator.length());
}
/**
* 截取最後一個分隔符後的字符串內容。
*
* @param str
* 待截取的字符串
* @param separator
* 分隔符
* @return 返回最後一個分隔符後的字符串內容。
*/
public static String substringAfterLast(String str, String separator) {
Assert.notEmpty(str);
Assert.notEmpty(separator);
int pos = str.lastIndexOf(separator);
if (pos == -1 || pos == (str.length() - separator.length())) {
return "";
}
return str.substring(pos + separator.length());
}
/**
*
* @param str
* @param beginIndex
* @param endIndex
* @return
* @since 2013-12-19
* @author Sunm
*/
public static String substring(String str, int beginIndex, int endIndex) {
if(endIndex > str.length() -1) {
endIndex = str.length();
}
return str.substring(beginIndex, endIndex);
}
/**
* 截取字符串，有截取時增加後綴.
* @param str
* @param beginIndex
* @param endIndex
* @param suffix
* @return
* @since 2013-12-19
* @author Sunm
*/
public static String substringWithSuffix(String str, int beginIndex, int endIndex, String suffix) {
int len = endIndex - beginIndex;
if(len > str.length()) {
suffix = "";
}
return substring(str, beginIndex, endIndex) + suffix;
}
/**
* 截取字符串，有截取時增加後綴(...).
* @param str
* @param beginIndex
* @param endIndex
* @return
* @since 2013-12-19
* @author Sunm
*/
public static String substringWithSuffix(String str, int beginIndex, int endIndex) {
return substringWithSuffix(str, beginIndex, endIndex, "...");
}
/**
* 截取指定起始位置和截取長度的字符串。
*
* @param str
* 待截取的字符串
* @param pos
* 起始位置
* @param len
* 截取長度
* @return 返回指定起始位置和截取長度的字符串。
*/
public static String mid(String str, int pos, int len) {
Assert.notEmpty(str);
Assert.isTrue(pos >= 0 && pos <= str.length());
Assert.isTrue(len >= 0);
if (str.length() <= (pos + len)) {
return str.substring(pos);
}
return str.substring(pos, pos + len);
}
/**
* 將一個字符串數組用指定分隔符串聯起來。
*
* @param strs
* 字符串數組
* @param separator
* 分隔符
* @return 返回串聯起來的字符串。
*/
public static String join(String[] strs, String separator) {
Assert.notEmpty(strs);
Assert.notNull(separator);
StringBuffer buf = new StringBuffer(256);
for (String str : strs) {
buf.append(str + separator);
}
String result = buf.toString();
if (!separator.isEmpty()) {
result = substringBeforeLast(result, separator);
}
return result;
}
/**
* 將一個字符串列表用指定分隔符串聯起來。
*
* @param strs
* 字符串數組
* @param separator
* 分隔符
* @return 返回串聯起來的字符串數組。
*/
public static String join(List<String> strs, String separator) {
return join(strs.toArray(new String[] {}), separator);
}
/**
* 對字符串進行字符集轉換。
*
* @param str
* 字符串
* @param origEncoding
* 原字符集編碼
* @param destEncoding
* 新字符集編碼
* @return 返回轉換後的字符串。
*/
public static String encode(String str, String origEncoding,
String destEncoding) {
try {
return new String(str.getBytes(origEncoding), destEncoding);
} catch (UnsupportedEncodingException e) {
throw new UncheckedException("對字符串進行字符集轉換時發生異常", e);
}
}
public static String toString(Object object) {
if(object == null) {
return "";
}
return object.toString();
}
/**
* 把一個字符創填充爲固定長度字符串
*
* @param str源字符串
* @param parame填充的字符
* @param length固定長度
* @return
*/
public static String setPre(String str,String parame,Integer length){
if(str.length()>=length){
return str;
}
else{
for(int i=str.length();i<length;i=str.length()){
str=parame+str;
}
return str;
}
}
/**
* 兩個數組作減法運算，arr1-arry2
* @param arr1
* @param arr2
* @return
*/
public static Object [] ArrayToRomeve(Object [] arr1,Object [] arr2){
if(arr2==null||arr2.length==0||arr1==null||arr1.length==0){
return arr1;
}
List<Object> list1=new ArrayList<Object>();
List<Object> list2=new ArrayList<Object>();
for(int i=0;i<arr1.length;i++){
list1.add(arr1[i]);
}
for(int i=0;i<arr2.length;i++){
list2.add(arr2[i]);
}
list1.removeAll(list2);
arr1=new String[list1.size()];
for(int i=0;i<list1.size();i++){
arr1[i]=list1.get(i);
}
return arr1;
}
/**
* 將字符串按數據庫的存儲位數標準截取指定長度，一個漢字在數據庫佔兩位
* @param content
* @param len
*/
public static String cutLength(String content,Integer len){
Pattern pattern=Pattern.compile("[\u4e00-\u9fa5]*");
Matcher m=pattern.matcher(content);
int len2=0;
while(m.find()){
len2+=m.group().length();
}
int len1=content.length();
if(len1+len2>len){
content=content.substring(0,len1-len2-100)+"長度超出"+len+"，已採取截斷處理";
}
return content;
}
}