cn.m1c.frame.utils.StringUtil Maven / Gradle / Ivy
package cn.m1c.frame.utils;
import java.io.UnsupportedEncodingException;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 2016年7月27日 字符串操作的帮助函数
* @author phil([email protected],m1c softCo.,ltd)
* @version lannie
*/
public abstract class StringUtil {
//(http|ftp|https)://[\w-]+(\.[\w-]+)+([\w.,@?^=%&:/~+#-]*[\w@?^=%&/~+#-])?
//var urlPattern = new Regexp("(http|ftp|https)://[\w-]+(\.[\w-]+)+([\w.,@?^=%&:/~+#-]*[\w@?^=%&/~+#-])?")
//var urlPattern = /(http|ftp|https):\/\/[\w-]+(\.[\w-]+)+([\w.,@?^=%&:\/~+#-]*[\w@?^=%&\/~+#-])?/
public static final String FOLDER_SEPARATOR = "/";
public static final String WINDOWS_FOLDER_SEPARATOR = "\\";
public static final String TOP_PATH = "..";
public static final String CURRENT_PATH = ".";
public static final char EXTENSION_SEPARATOR = '.';
//private static final char CHAR_SPACE = '\u0020';
//private static final char CHAR_CHINESE_SPACE = '\u3000';
/**
* 检查包含空白字符在内的字符系列长度
*
* StringUtils.hasLength(null) = false
* StringUtils.hasLength("") = false
* StringUtils.hasLength(" ") = true
* StringUtils.hasLength("Hello") = true
*
* 参数 str the CharSequence to check (may be null)
* 返回 true if the CharSequence is not null and has length
* @see #hasText(String)
*/
public static boolean hasLength(CharSequence str) {
return (str != null && str.length() > 0);
}
/**
* 检查包含空白字符在内的字符系列长度
* 参数 str the String to check (may be null)
* 返回 true if the String is not null and has length
* @see #hasLength(CharSequence)
*/
public static boolean hasLength(String str) {
return hasLength((CharSequence) str);
}
/**
* 检查字符串过滤前后空白后的长度
* 参数 str
* 返回 boolean
*/
public static boolean hasLengthAfterTrimWhiteSpace(String str) {
return str != null && str.trim().length() > 0;
}
public static boolean hasLengthBytrim(String str){
return hasLengthAfterTrimWhiteSpace(str);
}
/**
* Check whether the given CharSequence has actual text.
* More specifically, returns true if the string not null,
* its length is greater than 0, and it contains at least one non-whitespace character.
*
* StringUtils.hasText(null) = false
* StringUtils.hasText("") = false
* StringUtils.hasText(" ") = false
* StringUtils.hasText("12345") = true
* StringUtils.hasText(" 12345 ") = true
*
* 参数 str the CharSequence to check (may be null)
* 返回 true if the CharSequence is not null,
* its length is greater than 0, and it does not contain whitespace only
* @see Character#isWhitespace
*/
public static boolean hasText(CharSequence str) {
if (!hasLength(str)) {
return false;
}
int strLen = str.length();
for (int i = 0; i < strLen; i++) {
if (!Character.isWhitespace(str.charAt(i))) {
return true;
}
}
return false;
}
/**
* Check whether the given String has actual text.
* More specifically, returns true if the string not null,
* its length is greater than 0, and it contains at least one non-whitespace character.
* 参数 str the String to check (may be null)
* 返回 true if the String is not null, its length is
* greater than 0, and it does not contain whitespace only
* @see #hasText(CharSequence)
*/
public static boolean hasText(String str) {
return hasText((CharSequence) str);
}
public static int length(String str){
return hasLength(str) ? str.length() : 0;
}
/**
* 根据匹配串是提取占位符中的值
*
* 参数 url
* 原字符串
* 参数 ref
* 匹配串
* 参数 placeholder
* 占位符
* 返回 占位符中的值
*
* 示例: String ref = "list_*.html"; String url = "xxx/list_2578.html?a=1"; System.out.println(getParamValueInPlaceholder(url, ref, "\\*"));
*/
public static String getParamValueInPlaceholder(String url, String ref, String placeholder) {
String result = null;
try {
String[] refs = ref.split(placeholder);
String reg = "^.*" + refs[0] + "(.+?)";
if (refs.length > 1)
reg = "^.*" + refs[0] + "(.+?)" + refs[1] + ".*";
Pattern p = Pattern.compile(reg);
Matcher m = p.matcher(url);
if (m.matches()) {
result = m.group(1);
}
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
public static String getPointBefore(String str) {
try {
return str.split("\\.")[0];
} catch (Exception e) {
return str;
}
}
/**
* 截串
*
* 参数 source
* 参数 length
* 参数 fill
* 返回
*/
public static String getStringByLength(String source, int length, String fill) {
if (source == null)
return "";
if (source.length() < length + 1)
return source;
return source.substring(0, length) + fill;
}
/**
* getter方法名
* 参数 fieldName
* 返回
*/
public static String getterName(String fieldName) {
if (fieldName != null && !"".equals(fieldName)) {
fieldName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
}
return fieldName;
}
/**
* setter方法名
* 参数 fieldName
* 返回
*/
public static String setterName(String fieldName) {
if (fieldName != null && !"".equals(fieldName)) {
fieldName = "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
}
return fieldName;
}
/**
* 通过getter setter方法名取得字段名
*/
public static String fieldName(String getterMethodName) {
if(hasLengthAfterTrimWhiteSpace(getterMethodName) && getterMethodName.startsWith("get")){
return getterMethodName.substring(3, 4).toLowerCase() + getterMethodName.substring(4);
}
return getterMethodName;
}
/**
* 转换到Josn格式
* 参数 s
* 返回
*/
public static String string2Json(String s) {
StringBuilder sb = new StringBuilder(s.length() + 20);
sb.append('\"');
for (int i=0; i l; r--) {
if (!Character.isWhitespace(cs.charAt(r)))
break;
}
if (l > r)
return "";
else if (l == 0 && r == last)
return cs.toString();
return cs.subSequence(l, r + 1).toString();
}
/**
* 将字符串按半角逗号，拆分成数组，空元素将被忽略
*
* 参数 s
* 字符串
* 返回 字符串数组
*/
public static String[] splitIgnoreBlank(String s) {
return StringUtil.splitIgnoreBlank(s, ",");
}
/**
* 根据一个正则式，将字符串拆分成数组，空元素将被忽略
* 参数 s 字符串
* 参数 regex 正则式
* 返回 字符串数组
*/
public static String[] splitIgnoreBlank(String s, String regex) {
if (null == s)
return null;
String[] ss = s.split(regex);
List list = new LinkedList();
for (String st : ss) {
if (isBlank(st))
continue;
list.add(trim(st));
}
return list.toArray(new String[list.size()]);
}
/**
* 将一个整数转换成最小长度为某一固定数值的十进制形式字符串
*
* 参数 d 整数
* 参数 width 宽度
* 返回 新字符串
*/
public static String fillDigit(int d, int width) {
return alignRight(String.valueOf(d), width, '0');
}
/**
* 将一个整数转换成最小长度为某一固定数值的十六进制形式字符串
*
* 参数 d
* 整数
* 参数 width
* 宽度
* 返回 新字符串
*/
public static String fillHex(int d, int width) {
return alignRight(Integer.toHexString(d), width, '0');
}
/**
* 将一个整数转换成最小长度为某一固定数值的二进制形式字符串
*
* 参数 d 整数
* 参数 width 宽度
* 返回 新字符串
*/
public static String fillBinary(int d, int width) {
return alignRight(Integer.toBinaryString(d), width, '0');
}
/**
* 将一个整数转换成固定长度的十进制形式字符串
*
* 参数 d 整数
* 参数 width 宽度
* 返回 新字符串
*/
public static String toDigit(int d, int width) {
return StringUtil.cutRight(String.valueOf(d), width, '0');
}
/**
* 将一个整数转换成固定长度的十六进制形式字符串
*
* 参数 d 整数
* 参数 width 宽度
* 返回 新字符串
*/
public static String toHex(int d, int width) {
return StringUtil.cutRight(Integer.toHexString(d), width, '0');
}
/**
* 将一个整数转换成固定长度的二进制形式字符串
*
* 参数 d 整数
* 参数 width 宽度
* 返回 新字符串
*/
public static String toBinary(int d, int width) {
return StringUtil.cutRight(Integer.toBinaryString(d), width, '0');
}
/**
* 保证字符串为一固定长度。超过长度，切除，否则补字符。
*
* 参数 s 字符串
* 参数 width 长度
* 参数 c 补字符
* 返回 修饰后的字符串
*/
public static String cutRight(String s, int width, char c) {
if (null == s)
return null;
int len = s.length();
if (len == width)
return s;
if (len < width)
return StringUtil.dup(c, width - len) + s;
return s.substring(len - width, len);
}
/**
* 在字符串左侧填充一定数量的特殊字符
*
* 参数 cs 字符串
* 参数 width 字符数量
* 参数 c 字符
* 返回 新字符串
*/
public static String alignRight(CharSequence cs, int width, char c) {
if (null == cs)
return null;
int len = cs.length();
if (len >= width)
return cs.toString();
return new StringBuilder().append(dup(c, width - len)).append(cs).toString();
}
/**
* 在字符串右侧填充一定数量的特殊字符
*
* 参数 cs 字符串
* 参数 width 字符数量
* 参数 c 字符
* 返回 新字符串
*/
public static String alignLeft(CharSequence cs, int width, char c) {
if (null == cs)
return null;
int length = cs.length();
if (length >= width)
return cs.toString();
return new StringBuilder().append(cs).append(dup(c, width - length)).toString();
}
/**
* 参数 cs
* 字符串
* 参数 lc
* 左字符
* 参数 rc
* 右字符
* 返回 字符串是被左字符和右字符包裹 -- 忽略空白
*/
public static boolean isQuoteByIgnoreBlank(CharSequence cs, char lc, char rc) {
if (null == cs)
return false;
int len = cs.length();
if (len < 2)
return false;
int l = 0;
int last = len - 1;
int r = last;
for (; l < len; l++) {
if (!Character.isWhitespace(cs.charAt(l)))
break;
}
if (cs.charAt(l) != lc)
return false;
for (; r > l; r--) {
if (!Character.isWhitespace(cs.charAt(r)))
break;
}
return l < r && cs.charAt(r) == rc;
}
/**
* 参数 cs
* 字符串
* 参数 lc
* 左字符
* 参数 rc
* 右字符
* 返回 字符串是被左字符和右字符包裹
*/
public static boolean isQuoteBy(CharSequence cs, char lc, char rc) {
if (null == cs)
return false;
int length = cs.length();
return length > 1 && cs.charAt(0) == lc && cs.charAt(length - 1) == rc;
}
/**
* 获得一个字符串集合中，最长串的长度
*
* 参数 coll 字符串集合
* 返回 最大长度
*/
public static int maxLength(Collection coll) {
int re = 0;
if (null != coll)
for (CharSequence s : coll)
if (null != s)
re = Math.max(re, s.length());
return re;
}
/**
* 获得一个字符串数组中，最长串的长度
*
* 参数 array
* 字符串数组
* 返回 最大长度
*/
public static int maxLength(T[] array) {
int re = 0;
if (null != array)
for (CharSequence s : array)
if (null != s)
re = Math.max(re, s.length());
return re;
}
/**
* 对obj进行toString()操作,如果为null返回""
*
* 参数 obj
* 返回 obj.toString()
*/
public static String sNull(Object obj) {
return sNull(obj, "");
}
/**
* 对obj进行toString()操作,如果为null返回def中定义的值
*
* 参数 obj
* 参数 defaultValue
* 如果obj==null返回的内容
* 返回 obj的toString()操作
*/
public static String sNull(Object obj, String defaultValue) {
return obj != null ? obj.toString() : defaultValue;
}
/**
* 对obj进行toString()操作,如果为空串返回""
*
* 参数 obj
* 返回 obj.toString()
*/
public static String sBlank(Object obj) {
return sBlank(obj, "");
}
/**
* 对obj进行toString()操作,如果为空串返回def中定义的值
*
* 参数 obj
* 参数 def
* 如果obj==null返回的内容
* 返回 obj的toString()操作
*/
public static String sBlank(Object obj, String def) {
if (null == obj)
return def;
String s = obj.toString();
return StringUtil.isBlank(s) ? def : s;
}
/**
* 截去第一个字符
*
* 比如:
*
* - removeFirst("12345") ＝》 2345
*
- removeFirst("A") ＝》 ""
*
*
* 参数 str
* 字符串
* 返回 新字符串
*/
public static String removeFirst(CharSequence str) {
if (str == null)
return null;
if (str.length() > 1)
return str.subSequence(1, str.length()).toString();
return "";
}
/**
* 如果str中第一个字符和 c一致,则删除,否则返回 str
*
* 比如:
*
* - removeFirst("12345",1) ＝》 "2345"
*
- removeFirst("ABC",'B') ＝》 "ABC"
*
- removeFirst("A",'B') ＝》 "A"
*
- removeFirst("A",'A') ＝》 ""
*
*
* 参数 str
* 字符串
* 参数 c
* 第一个个要被截取的字符
* 返回 新字符串
*/
public static String removeFirst(String str, char c) {
return (StringUtil.isEmpty(str) || c != str.charAt(0)) ? str : str.substring(1);
}
/**
* 判断一个字符串数组是否包括某一字符串
*
* 参数 ss
* 字符串数组
* 参数 s
* 字符串
* 返回 是否包含
*/
public static boolean isin(String[] ss, String s) {
if (null == ss || ss.length == 0 || StringUtil.isBlank(s))
return false;
for (String w : ss)
if (s.equals(w))
return true;
return false;
}
/**
* 将一个字符串某一个字符后面的字母变成大写，比如
*
*
* upperWord("hello-world", '-') 》 "helloWorld"
*
*
* 参数 s
* 字符串
* 参数 c
* 字符
*
* 返回 转换后字符串
*/
public static String upperWord(CharSequence s, char c) {
StringBuilder sb = new StringBuilder();
int len = s.length();
for (int i = 0; i < len; i++) {
char ch = s.charAt(i);
if (ch == c) {
do {
i++;
if (i >= len)
return sb.toString();
ch = s.charAt(i);
} while (ch == c);
sb.append(Character.toUpperCase(ch));
} else {
sb.append(ch);
}
}
return sb.toString();
}
public static int indexOf(String referer, String string) {
if(hasLengthBytrim(referer)){
return referer.indexOf(string);
}
return -1;
}
/**
* 根据某种编码方式将字节数组转换成字符串
* 参数 b 字节数组
* 参数 offset 要转换的起始位置
* 参数 len 要转换的长度
* 参数 encoding 编码方式
* 返回 如果encoding不支持，返回一个缺省编码的字符串
*/
public static String getString(byte[] b, int offset, int len, String encoding) {
try {
return new String(b, offset, len, encoding);
} catch (UnsupportedEncodingException e) {
return new String(b, offset, len);
}
}
public static String toHexString(byte[] buf) {
return toHexString(buf, null, Integer.MAX_VALUE);
}
private static final char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
public static String toHexString(byte[] buf, String sep, int lineLen) {
if (buf == null)
return null;
if (lineLen <= 0)
lineLen = Integer.MAX_VALUE;
StringBuffer res = new StringBuffer(buf.length * 2);
for (int i = 0; i < buf.length; i++) {
int b = buf[i];
res.append(HEX_DIGITS[(b >> 4) & 0xf]);
res.append(HEX_DIGITS[b & 0xf]);
if (i > 0 && (i % lineLen) == 0)
res.append('\n');
else if (sep != null && i < lineLen - 1)
res.append(sep);
}
return res.toString();
}
private static final int charToNibble(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
} else if (c >= 'a' && c <= 'f') {
return 0xa + (c - 'a');
} else if (c >= 'A' && c <= 'F') {
return 0xA + (c - 'A');
} else {
return -1;
}
}
public static byte[] fromHexString(String text) {
text = text.trim();
if (text.length() % 2 != 0)
text = "0" + text;
int resLen = text.length() / 2;
int loNibble, hiNibble;
byte[] res = new byte[resLen];
for (int i = 0; i < resLen; i++) {
int j = i << 1;
hiNibble = charToNibble(text.charAt(j));
loNibble = charToNibble(text.charAt(j + 1));
if (loNibble == -1 || hiNibble == -1)
return null;
res[i] = (byte) (hiNibble << 4 | loNibble);
}
return res;
}
public static final boolean isChinese(String strName) {
char[] ch = strName.toCharArray();
for (int i = 0; i < ch.length; i++) {
char c = ch[i];
if (isChinese(c)) {
return true;
}
}
return false;
}
public static final boolean isChinese(char c) {
if( ((int)c) > 127){
Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
return 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 false;
}
/**
* 清除 小数末尾精度多余0
* 参数 str(9.12000)
* 返回 9012
*/
public static String trimZero(String str) {
if (str.indexOf(".") != -1 && str.charAt(str.length() - 1) == '0') {
return trimZero(str.substring(0, str.length() - 1));
} else {
return str.charAt(str.length() - 1) == '.' ? str.substring(0, str.length() - 1) : str;
}
}
/**
* List转换String
*
* 参数 list
* :需要转换的List
* 返回 String转换后的字符串
*/
public static String ListToString(List list,String sep) {
StringBuffer sb = new StringBuffer();
if (list != null && list.size() > 0) {
for (int i = 0; i < list.size(); i++) {
if (list.get(i) == null || list.get(i) == "") {
continue;
}
sb.append(list.get(i));
sb.append(sep);
}
}
return (sb.toString());
}
/**
* 把字符串的除了前m位和后n位，其余位用“*”号代替
* 参数 str 要代替的字符串
* 参数 m 不做变化的前m位数
* 参数 n 不做变化后n位数
* 返回
*/
public static String replaceSubString(String str, int m, int n) {
if(str == null) {
return null;
}
String sub = "";
String subPrefix = "";
String subSuffix = "";
int strLen = str.length();
subPrefix = str.substring(0, m);
subSuffix = str.substring(strLen-n, strLen);
StringBuffer sb=new StringBuffer();
for(int i=0;i<(strLen-m-n);i++){
sb=sb.append("*");
}
sub = subPrefix + sb.toString() + subSuffix;
return sub;
}
/**
* 截取字符串后4位，不满4位返回空串
* 参数 str
* 返回
*/
public static String getLast4(String str){
if(str!=null && str.length()>=4){
return str.substring(str.length()-4);
}else{
return "";
}
}
}