常用的字符串工具类

工具类

提供了更多的方法，操作更简便；
相比于原生方法 str.xxx() str为null会发生NPE，StringUtils.xxx(str, …) 把str作为参数，str为null时也能正常执行，兼容了null等特殊情况。

常见的字符串工具类比如 common-lang3、spring的StringUtils，common-lang3的StringUtils方法更齐全，推荐使用。

commons-lang3的CharSequenceUtils

//CharSequence转char[]
char[] chars = CharSequenceUtils.toCharArray(charSequence);

//提取子串，从指定位置到末尾。null返回null
CharSequence charSequence = CharSequenceUtils.subSequence(charSequence, startIndex);

commons-lang3的StringUtils

老版本的类库是 commons-lang，新版本是 commons-lang3，尽量用 lang3 代替 lang。commons-lang3 的 StringUtils 也是字符串最常用的工具类。

依赖

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.11</version>
</dependency>

常用常量

spring的StringUtils没有提供常量，common-lang3提供了一些字符串常量

//空串
String empty = StringUtils.EMPTY;

//换行符\n
String lf = StringUtils.LF;

//空格串，一个空格" "
String space = StringUtils.SPACE;

//找不到对应index时返回的-1
int indexNotFound = StringUtils.INDEX_NOT_FOUND;

is

//判断字符串是否为empty，null、空串都是empty
boolean b1 = StringUtils.isEmpty("xxx");
boolean b2 = StringUtils.isNotEmpty("xxx");

//判断字符串是否是blank，null、空串、空格串都是blank
boolean b3 = StringUtils.isBlank("xxx");
boolean b4 = StringUtils.isNotBlank("xxx");


//其中一些字符串是否是empty|blank的
boolean anyEmpty = StringUtils.isAnyEmpty(str1, str2, str3);
boolean anyBlank = StringUtils.isAnyBlank(str1, str2, str3);

//这些字符串是全部是empty|blank的
boolean allEmpty = StringUtils.isAllEmpty(str1, str2, str3);
boolean allBlank = StringUtils.isAllBlank(str1, str2, str3);


//字符串是否只包含阿拉伯数字。小数点、正负号不属于阿拉伯数字，返回false；null、空串返回false
boolean numeric = StringUtils.isNumeric(str);
//字符串是否只包含英文字母，null、空串返回false
boolean alpha = StringUtils.isAlpha(str);
//字符串是否是空白符（空串、空格串），null返回false
boolean whitespace = StringUtils.isWhitespace(str);

empty、blank的异同点：都包含了null、空串，blank还包含了空格串。

equals

//比较2个字符串是否equals
boolean equals1 = StringUtils.equals(str1, str2);
boolean equals2 = StringUtils.equalsIgnoreCase(str1, str2);

//是否和指定字符串中的某一个equals
boolean equals3 = StringUtils.equalsAny(str, str1, str2, str3);
boolean equals4 = StringUtils.equalsAnyIgnoreCase(str, str1, str2, str3);

contains

//是否包含指定字符串
boolean b1 = StringUtils.contains(str, "h");
boolean b2 = StringUtils.containsIgnoreCase(str, "H");

//是否包含指定字符中的某个字符，只要包含其中一个即可。指定字符可以写成String或char...
boolean b3 = StringUtils.containsAny(str, "Hh");
boolean b4 = StringUtils.containsAny(str, 'H', 'h');

//是否包含指定字符串中的某个字符串
boolean b5 = StringUtils.containsAny(str, "He", "he");

//是否不包含指定字符中的任意一个字符
boolean b6 = StringUtils.containsNone(str, "Hh");
boolean b7 = StringUtils.containsNone(str, 'H', 'h');

//是否只包含指定字符
boolean b8 = StringUtils.containsOnly(str, "Hh");
boolean b9 = StringUtils.containsOnly(str, 'H', 'h');

//是否包含空白符。如果str是empty的，直接返回false
boolean b10 = StringUtils.containsWhitespace(str);

如果远传其中一个参数为null，直接返回false

replace、remove

//替换指定字符串，会替换所有出现处
String str1 = StringUtils.replace(str, "he", "He");
//匹配时忽略大小写
String str2 = StringUtils.replaceIgnoreCase(str, "he", "He");

//可以指定替换次数，未指定时默认-1 全部提换（不限制提换次数）
String str3 = StringUtils.replace(str, "he", "He", 3);
String str4 = StringUtils.replaceIgnoreCase(str, "he", "He", 3);

//只提换1次
String str5 = StringUtils.replaceOnce(str, "he", "He");
String str6 = StringUtils.replaceOnceIgnoreCase(str, "he", "He");

//替换多个字符串，2个数组对应位置上的元素一一对应
//同时在原串上进行替换 dcte
String str7 = StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"});
//数组元素依次进行替换，后续元素在之前元素替换后的结果上进行操作 tcte
String str8 = StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"});



//移除所有匹配的子串
String str1 = StringUtils.remove(str, "el");
//移除开头处的指定字符串
String str2 = StringUtils.removeStart(str, "he");
//移除末尾处的指定字符串
String str3 = StringUtils.removeEnd(str, "lo");

//匹配时不区分大小写
String str4 = StringUtils.removeIgnoreCase(str, "el");
String str5 = StringUtils.removeStartIgnoreCase(str, "he");
String str6 = StringUtils.removeEndIgnoreCase(str, "lo");

都是在副本上修改，返回副本，原串不变。

indexOf

//查找指定字符、字符串第一次出现的位置，找不到则返回-1
int index1 = str.indexOf("xxx");
//查找指定字符、字符串最后一次出现的位置，找不到则返回-1
int index2 = str.lastIndexOf("l");

//都可以指定查找开始位置
int index3 = str.indexOf("xxx", 5);
int index4 = str.lastIndexOf("l", 5);

default

//如果str不为null，返回str；如果str为null返回指定的默认字符串
String str1=StringUtils.defaultString(str,"默认字符串");
//默认字符串为空串
String str2=StringUtils.defaultString(str);

//如果str是blank|empty，返回默认字符串
String str3 = StringUtils.defaultIfBlank(str, "默认字符串");
String str4 = StringUtils.defaultIfEmpty(str, "默认字符串");

wrap、prepend、append、pad 两端字符填充

//在两端直接加上指定字符串
String str1 = StringUtils.wrap(str, "xxx");
//在两端加上指定字符串。缺失的一端才加上，如果这端已经有了，则不再添加
String str3 = StringUtils.wrapIfMissing(str, "xxx");
//去除两端的指定子串。要两端同时是指定子串才去除，否则不去除
String str2 = StringUtils.unwrap(str, "xxx");


//如果str开头缺失子串str2，在str开头添加子串str1
StringUtils.prependIfMissing(str, str1, str2);
//如果str末尾缺失子串str2，则在str末尾添加子串str1
StringUtils.appendIfMissing(str, str1, str2);

//匹配时忽略大小写
StringUtils.prependIfMissingIgnoreCase(str, str1, str2);
StringUtils.appendIfMissingIgnoreCase(str, str1, str2);


//两端自动填充，字符串长度不够时自动在两端填充指定字符，第二个参数指定目标字符数，第三个参数指定填充字符，缺省时默认为空格
str7 = StringUtils.leftPad(str, 10, "0");
str8 = StringUtils.rightPad(str, 10, "0");

trim、strip 移除两端特殊字符

//trim系列：移除字符串两端的空格，以及\n、\t之类的特殊字符
//strip系列：使用方式和trim系列相同，但strip只移除字符串两端的空格

//如果参数是null，返回null；如果处理后是空串，返回空串
String str1 = StringUtils.trim("xxx");
//如果参数是null或者处理后是空串，均返回null
String str3 = StringUtils.trimToNull("xxx");
//如果参数是null或者处理后是空串，均返回空串
String str2 = StringUtils.trimToEmpty("xxx");

String str4 = StringUtils.strip("xxx");
String str5 = StringUtils.stripToNull("xxx");
String str6 = StringUtils.stripToEmpty("xxx");

startsWith、endsWith

//是否以指定字符串开头
boolean b1 = StringUtils.startsWith(str, "he");
boolean b2 = StringUtils.startsWithIgnoreCase(str, "He");
//是否以指定字符串中的某一个开头
boolean b3 = StringUtils.startsWithAny(str, "he", "HE", "He");

//endsWith 系列使用方式相同

countMatches 字符统计、reverse字符串反转、upperCase、lowerCase

//统计字符|字符串出现的次数
int count1 = StringUtils.countMatches(str, 'l');
int count2 = StringUtils.countMatches(str, "he");


//字符串反转
String reverse = StringUtils.reverse(str);


//转换为全大|小写
String str1 = StringUtils.upperCase(str);
String str2 = StringUtils.lowerCase(str);

spring的StringUtils

判断、统计

//StringUtils.isEmpty()已过时，可以用以下3个方法代替

//字符串长度是否 >0，null、空串 => false
boolean b1 = StringUtils.hasLength("xxx");

//null、空串、空格串返回false
boolean b2 = StringUtils.hasText("xxx");

//判断 Object 或 Object[] 是否为空，null、空串、空数组 => true
boolean b3 = ObjectUtils.isEmpty("xxx");


//是否以指定字符串开头|结尾，匹配时忽略大小写
boolean b1 = StringUtils.startsWithIgnoreCase("hello", "H");
boolean b2 = StringUtils.endsWithIgnoreCase("hello", "o");


//统计子串出现次数
int count = StringUtils.countOccurrencesOf("hello", "l");

删除、替换

//删除匹配到的所有子串
String str2 = StringUtils.delete("hello", "l");

//删除匹配到的所有单个字符。会把第二个参数作为char数组，删除所有匹配到的char
String str3 = StringUtils.deleteAny("hello", "hl");


//替换子串，会替换所有匹配的子串
String str4 = StringUtils.replace("hello", "h", "H");


//去除两端的空格
String str = StringUtils.trimWhitespace(" hello ");

盘符、路径

//分号
System.out.println(File.pathSeparator);

//linux路径是/，win路径是\\
System.out.println("/usr/local/".endsWith(File.separator));


//判斷2个盘符是否等价，会自动转换\\、/，但不会去掉、补上首尾的斜杠
boolean b = StringUtils.pathEquals("/usr/local/", "\\usr\\local\\");

//拼接2个路径，会自动处理拼接处多余的/，要求: /、\\不能混用，拼接处的/可以多，但不能少
String str1 = StringUtils.applyRelativePath("/sur/","/local/upload");

//将path中的\\转换为/
String str2 = StringUtils.cleanPath("/usr/local\\upload");


//获取文件名（带后缀）
String filename = StringUtils.getFilename("/usr/local/upload/xxx.png");

//获取扩展名（不带.)
String filenameExtension = StringUtils.getFilenameExtension("/usr/local/upload/xxx.png");

String数组、集合

//移除string数组中的重复元素
String[] arr2 = StringUtils.removeDuplicateStrings(arr1);

//字符串数组排序，默认逐个字符按ASCII码值比较，升序
String[] arr1 = StringUtils.sortStringArray(arr);

//连接2个String数组
String[] arr3 = StringUtils.concatenateStringArrays(arr1, arr2);


//Object[]拼接为String，默认使用逗号作为连接符，可指定连接符
//注意是Object[]，不局限于String[]
String str1 = StringUtils.arrayToCommaDelimitedString(arr);
String str2 = StringUtils.arrayToDelimitedString(arr, "_");

//Collection<Object> 拼接为String
String str3 = StringUtils.collectionToCommaDelimitedString(collection);
String str4 = StringUtils.collectionToDelimitedString(collection, "_");


//collection<String>转String[]
String[] arr2 = StringUtils.toStringArray(collection);

hutool的CharSequenceUtil

hutool的字符串工具类是 CharSequenceUtil，不叫 StringUtil。

常用常量

//空串
String empty = CharSequenceUtil.EMPTY;
//空格串
String space = CharSequenceUtil.SPACE;

类型转换

//CharSequence转String
String str = CharSequenceUtil.str(cs);


//CharSequence转byte[]，可以指定String、Charset格式的字符集，缺省时使用jvm默认字符集
byte[] bytes = CharSequenceUtil.bytes(cs);
byte[] bytes = CharSequenceUtil.bytes(cs, "utf-8");
byte[] bytes = CharSequenceUtil.bytes(cs, StandardCharsets.UTF_8);

两端字符处理

//如果不是指定的前后缀，则加上，返回操作后的字符串（已经有指定的前后缀，则返回原串）
String str = CharSequenceUtil.addPrefixIfNot(cs, prefix);
String str = CharSequenceUtil.addSuffixIfNot(cs, suffix);


//如果前缀不是prefixes中的某一个，则加上指定前缀prefix，返回操作后的字符串
String str = CharSequenceUtil.prependIfMissing(cs, prefix, boolean ignoreCase, CharSequence... prefixes);  //ignoreCase指定匹配时是否区分大小写
String str = CharSequenceUtil.prependIfMissing(cs, prefix, CharSequence... prefixes);  //ignoreCase为false 匹配时不忽略大小写
String str = CharSequenceUtil.prependIfMissingIgnoreCase(cs, prefix, CharSequence... prefixes);  //ignoreCase为true 匹配时忽略大小写

//appendIfMissing系列，后缀，使用方式同上


//移除空白符
String str = CharSequenceUtil.trim(cs);  //同时移除首尾，null返回null
String str = CharSequenceUtil.trimStart(cs);  //只移除开头的
String str = CharSequenceUtil.trimEnd(cs);  //只移除末尾的
String str = CharSequenceUtil.trimToNull(cs);  //如果移除后是空串，返回null（null自然也是返回null）
String str = CharSequenceUtil.trimToEmpty(cs);  //如果移除后是null，返回空串（空串自然也是返回空串）

内容格式

//将字符串摘要为指定长度，brief 摘要、概要、简短的
//取2端，中间部分填充点号；原串长度不足或maxLength<=0时，返回原串
String brief = CharSequenceUtil.brief(cs, maxLength);


//将cs居中，两边填充pad，使字符串长度达到size。cs长度>=size时返回原串
String center = CharSequenceUtil.center(cs, size, padCs);  //pad使用cs类型，为empty时默认使用空格
String center = CharSequenceUtil.center(cs, size, padChar);  //pad使用char类型
String center = CharSequenceUtil.center(cs, size); //pad使用空格


//在cs末尾填充ch，使长度达到length。如果原串长度>=length，则返回原串
String str = CharSequenceUtil.fixLength(cs, ch, length);

//获取字符串长度，null返回0
int length = CharSequenceUtil.length(cs);

//保证字符串长度不超过length，<=length时返回原串，>length时超出部分替换为...
String str = CharSequenceUtil.maxLength(cs, length);


//移除cs中的空白符
String s = CharSequenceUtil.cleanBlank(cs);

//格式化字符串，将原串中的{}替换为对应的值
String str = CharSequenceUtil.format(cs, Object...);


//字符串脱敏，脱敏策略定义在枚举类 DesensitizedUtil.DesensitizedType 中
//支持用户id、中文名、身份证号、座机号、手机号、地址、电子邮件、密码、中国大陆车牌、银行卡
String desensitized = CharSequenceUtil.desensitized(cs, DesensitizedUtil.DesensitizedType.MOBILE_PHONE);

//将[startIndex,endIndex)上的字符替换为*，即指定区间脱敏、隐藏
String hide = CharSequenceUtil.hide(cs, startIndex, endIndex);

连接、切割

//传入初始值，构建StringBuilder对象
StringBuilder sb = CharSequenceUtil.builder(CharSequence... strs);

//连接多个字符串。isNullToEmpty指定是否将null作为空串处理，实际上不管设置为true还是false，都是作为空串处理
String concat1 = CharSequenceUtil.concat(isNullToEmpty, cs...);

//以cs作为分隔符，连接多个对象
String str = CharSequenceUtil.join(cs, Object... objs);
String str = CharSequenceUtil.join(cs, Iterable<T> iterable);


//重复指定次数
String str = CharSequenceUtil.repeat(ch|cs, count);
//指定连接符
String str = CharSequenceUtil.repeatAndJoin(cs, count, delimiter);
//重复字符串，直到长度达到length
String str = CharSequenceUtil.repeatByLength(cs, length);

contains、has

//是否包含指定ch、cs
boolean contains = CharSequenceUtil.contains(cs, ch|cs);
boolean containsIgnoreCase = CharSequenceUtil.containsIgnoreCase(cs, cs);

//是否包含其中某个字符，只要包含其中一个即可
boolean containsAny = CharSequenceUtil.containsAny(cs,ch|cs...);
boolean containsAnyIgnoreCase = CharSequenceUtil.containsAnyIgnoreCase(cs, cs...);

//是否只包含指定字符
boolean containsOnly = CharSequenceUtil.containsOnly(cs, ch...);

//是否包含空白符
boolean containsBlank = CharSequenceUtil.containsBlank(cs);


//遍历subcs数组，返回第一个包含在cs中的元素，都不包含则返回null
String str = CharSequenceUtil.getContainsStr(cs, subCs...);
String str = CharSequenceUtil.getContainsStrIgnoreCase(cs, cs...);

//遍历subcs数组，返回第一个包含在cs中的元素，都不包含则返回null
String str = CharSequenceUtil.getContainsStr(cs, subCs...);
String str = CharSequenceUtil.getContainsStrIgnoreCase(cs, cs...);


//数组中是否有empty|blank的元素，如果数组本身是empty的也会返回true
boolean hasEmpty = CharSequenceUtil.hasEmpty(cs...);
boolean hasBlank = CharSequenceUtil.hasBlank(cs...);

startWith、endWith

//是否以指定字符、字符串结尾
boolean endWith = CharSequenceUtil.endWith(cs, ch|cs);
boolean endWithIgnoreCase = CharSequenceUtil.endWithIgnoreCase(cs, cs);

//匹配时是否忽略大小写，是否忽略字符串相等的情况。ignoreEquals，true 字符串相等不算是以之结尾，false 字符串相等算是以之结尾
boolean endWith = CharSequenceUtil.endWith(cs, cs, ignoreCase, ignoreEquals);
//缺省ignoreEquals时默认为false，一般也使用false
boolean endWith = CharSequenceUtil.endWith(cs, cs, ignoreCase);

//是否以其中某个字符串结尾
boolean endWithAny = CharSequenceUtil.endWithAny(cs, cs...);
boolean endWithAnyIgnoreCase = CharSequenceUtil.endWithAnyIgnoreCase(cs, cs...);

//startWith系列用法相同，多了一个 startWithIgnoreEquals() 方法

equals

//是否相等
boolean equals = CharSequenceUtil.equals(cs, cs);
boolean equals = CharSequenceUtil.equals(cs, cs, ignoreCase);
boolean equalsIgnoreCase = CharSequenceUtil.equalsIgnoreCase(cs, cs);

//是否等于其中一个
boolean equalsAny = CharSequenceUtil.equalsAny(cs, cs...);
boolean equalsAny = CharSequenceUtil.equalsAny(cs, ignoreCase, cs...);
boolean equalsAny = CharSequenceUtil.equalsAnyIgnoreCase(cs, cs...);

//指定位置上的字符是否与指定字符相等
boolean equalsCharAt = CharSequenceUtil.equalsCharAt(cs, index, ch);

is

boolean isEmpty = CharSequenceUtil.isEmpty(cs);
boolean isBlank = CharSequenceUtil.isBlank(cs);

boolean isNotEmpty = CharSequenceUtil.isNotEmpty(cs);
boolean isNotBlank = CharSequenceUtil.isNotBlank(cs);


//是否全部为empty、blank
boolean isAllEmpty = CharSequenceUtil.isAllEmpty(cs...);
boolean isAllBlank = CharSequenceUtil.isAllBlank(cs...);

//是否都不是empty、blank
boolean isAllNotEmpty = CharSequenceUtil.isAllNotEmpty(cs...);
boolean isAllNotBlank = CharSequenceUtil.isAllNotBlank(cs...);

//是否所有字符都满足匹配、要求
boolean isAllCharMatch = CharSequenceUtil.isAllCharMatch(cs, character -> CharUtil.isNumber(character));


//是否是null、empty、blank或者未定义。未定义指的是值为"null"或"undefined"的字符串
boolean isNullOrUndefined = CharSequenceUtil.isNullOrUndefined(cs);
boolean isEmptyOrUndefined = CharSequenceUtil.isEmptyOrUndefined(cs);
boolean isBlankOrUndefined = CharSequenceUtil.isBlankOrUndefined(cs);


//是否全部为数字、大小写
boolean isNumeric = CharSequenceUtil.isNumeric(cs);
boolean isLowerCase = CharSequenceUtil.isLowerCase(cs);  //如果不是字母，也算是小写
boolean isUpperCase = CharSequenceUtil.isUpperCase(cs);  //如果不是字母，也算是大写

//字符串中的所有字符是否都相同
boolean isCharEquals = CharSequenceUtil.isCharEquals(cs);


//是否被指定前后缀包围（是否是指定的前后缀）
boolean isSurround = CharSequenceUtil.isSurround(cs, prefixCh, suffixCh);
boolean isSurround = CharSequenceUtil.isSurround(cs, prefixCs, suffixCs);

//同上，是否被指定前后缀包围
boolean isWrap = CharSequenceUtil.isWrap(cs, prefixCh, suffixCh);
boolean isWrap = CharSequenceUtil.isWrap(cs, prefixStr, suffixStr);

//是否被指定字符|字符串包围（前后缀都是指定字符）
boolean isWrap = CharSequenceUtil.isWrap(cs, ch|str);

indexOf

//在[startIndex,endIndex)区间上查找指定字符，返回下标，startIndex<0时自动取0，endIndex超过字符串末尾时自动取末尾
int index = CharSequenceUtil.indexOf(cs, ch, startIndex, endIndex);
//缺省endIdex时默认到末尾
int index = CharSequenceUtil.indexOf(cs, ch, startIndex);
//缺省startIndex、endIndex时默认在整个范围内检索
int index = CharSequenceUtil.indexOf(cs, ch);

//检索子串位置
int index = CharSequenceUtil.indexOf(cs, searchCs, startIndex, isIgnoreCase);
int index = CharSequenceUtil.indexOf(cs, searchCs, startIndex);
int index = CharSequenceUtil.indexOf(cs, searchCs);

//last从后往前检索
int index = CharSequenceUtil.lastIndexOf(cs, searchCs, startIndex, isIgnoreCase);
int index = CharSequenceUtil.lastIndexOfIgnoreCase(cs, searchCs, startIndex);
int index = CharSequenceUtil.lastIndexOfIgnoreCase(cs, searchCs);

//返回子串在原串中第n次出现的位置。如果没有或次数达不到n，都是返回-1
int index = CharSequenceUtil.ordinalIndexOf(cs, searchCs, n);

兼容空串

//兼容null，为null时返回默认字符串|空串
String str = CharSequenceUtil.nullToDefault(cs, defaultStr);
String str = CharSequenceUtil.nullToEmpty(cs);
String str = CharSequenceUtil.emptyIfNull(cs);

//为empty时取null|默认字符串
String str = CharSequenceUtil.emptyToNull(cs);
String str = CharSequenceUtil.emptyToDefault(cs, defaultStr);

//为blank时返回默认字符串
String str = CharSequenceUtil.blankToDefault(cs, defaultStr);

wrap、unWrap 前后缀处理

//加上前后缀
String str = CharSequenceUtil.wrap(cs, prefix, suffix);
String str = CharSequenceUtil.wrap(cs, prefixAndSuffix);  //前后缀相同
String str = CharSequenceUtil.wrapIfMissing(cs, prefix, suffix);  //缺失指定的前|后缀时才加上

//给多个字符串都加上前后缀
String str = CharSequenceUtil.wrapAll(prefix, suffix, cs...);
String str = CharSequenceUtil.wrapAllIfMissing(prefix, suffix, cs...);  //缺失时才加上
String str = CharSequenceUtil.wrapAllWithPair(prefixAndSuffix, cs...);  //前后缀相同
String str = CharSequenceUtil.wrapAllWithPairIfMissing(prefixAndSuffix, cs...);  //缺失时才加上、前后缀相同

//移除指定的前|后缀。前后缀可以是char、cs类型，如果原串没有指定的前|后缀，则不移除
String str = CharSequenceUtil.unWrap(cs, prefix, suffix);
String str = CharSequenceUtil.unWrap(cs, prefixAndSuffix);  //前后缀相同

其它

//返回第一个非null、empty、blank的元素
CharSequence cs = CharSequenceUtil.firstNonNull(cs...);
CharSequence cs = CharSequenceUtil.firstNonEmpty(cs...);
CharSequence cs = CharSequenceUtil.firstNonBlank(cs...);


//比较版本号大小
int i = CharSequenceUtil.compareVersion(CharSequence version1, CharSequence version2);

ChineseHelper 繁简字转换

 <dependency>
     <groupId>com.github.stuxuhai</groupId>
     <artifactId>jpinyin</artifactId>
     <version>1.1.8</version>
 </dependency>

//简体 => 繁体
String fanStr = ChineseHelper.convertToTraditionalChinese(jianStr);

//繁体 => 简体
String jianStr = ChineseHelper.convertToSimplifiedChinese(fanStr);

原文链接：https://blog.csdn.net/chy_18883701161/article/details/120564599

目录

commons-lang3的CharSequenceUtils

commons-lang3的StringUtils

依赖

常用常量

is

equals

contains

replace、remove

indexOf

default

wrap、prepend、append、pad 两端字符填充

trim、strip 移除两端特殊字符

startsWith、endsWith

countMatches 字符统计、reverse字符串反转、upperCase、lowerCase

spring的StringUtils

判断、统计

删除、替换

盘符、路径

String数组、集合

hutool的CharSequenceUtil

常用常量

类型转换

两端字符处理

内容格式

连接、切割

contains、has

startWith、endWith

equals

is

indexOf

兼容空串

wrap、unWrap 前后缀处理

其它

ChineseHelper 繁简字转换