ZhouXY108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-04-19 03:01:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix code

Browse Source
This commit is contained in:
Looly 2023-03-26 17:15:17 +08:00
parent 7581ab6428
commit a745f1be80
40 changed files with 550 additions and 812 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
hutool-core/src/main/java/cn/hutool/core/bean/BeanInfoCache.java
View File

@ -14,6 +14,9 @@ import java.util.Map;
* @author Looly
*/
public enum BeanInfoCache {
/**
* 单例
*/
INSTANCE;
private final WeakConcurrentMap<Class<?>, Map<String, PropertyDescriptor>> pdCache = new WeakConcurrentMap<>();

9
hutool-core/src/main/java/cn/hutool/core/bean/BeanPath.java
View File

@ -6,6 +6,7 @@ import cn.hutool.core.convert.Convert;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.math.NumberUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.CharUtil;
@ -190,9 +191,9 @@ public class BeanPath implements Serializable {
return null;
}
if (StrUtil.contains(expression, ':')) {
if (StrUtil.contains(expression, CharUtil.COLON)) {
// [start:end:step] 模式
final List<String> parts = StrUtil.splitTrim(expression, ':');
final List<String> parts = SplitUtil.splitTrim(expression, StrUtil.COLON);
final int start = Integer.parseInt(parts.get(0));
final int end = Integer.parseInt(parts.get(1));
int step = 1;
@ -206,7 +207,7 @@ public class BeanPath implements Serializable {
}
} else if (StrUtil.contains(expression, ',')) {
// [num0,num1,num2...]模式或者['key0','key1']模式
final List<String> keys = StrUtil.splitTrim(expression, ',');
final List<String> keys = SplitUtil.splitTrim(expression, StrUtil.COMMA);
if (bean instanceof Collection) {
return CollUtil.getAny((Collection<?>) bean, Convert.convert(int[].class, keys));
} else if (ArrayUtil.isArray(bean)) {
@ -214,7 +215,7 @@ public class BeanPath implements Serializable {
} else {
final String[] unWrappedKeys = new String[keys.size()];
for (int i = 0; i < unWrappedKeys.length; i++) {
unWrappedKeys[i] = StrUtil.unWrap(keys.get(i), '\'');
unWrappedKeys[i] = StrUtil.unWrap(keys.get(i), CharUtil.SINGLE_QUOTE);
}
if (bean instanceof Map) {
// 只支持String为key的Map

3
hutool-core/src/main/java/cn/hutool/core/codec/Morse.java
View File

@ -2,6 +2,7 @@ package cn.hutool.core.codec;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.CharUtil;
import java.util.HashMap;
@ -153,7 +154,7 @@ public class Morse {
if (false == StrUtil.containsOnly(morse, dit, dah, split)) {
throw new IllegalArgumentException("Incorrect morse.");
}
final List<String> words = StrUtil.split(morse, split);
final List<String> words = SplitUtil.split(morse, String.valueOf(split));
final StringBuilder textBuilder = new StringBuilder();
Integer codePoint;
for (String word : words) {

8
hutool-core/src/main/java/cn/hutool/core/codec/PunyCode.java
View File

@ -3,6 +3,7 @@ package cn.hutool.core.codec;
import cn.hutool.core.exceptions.UtilException;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.CharUtil;
import java.util.List;
@ -24,8 +25,7 @@ public class PunyCode {
private static final int DAMP = 700;
private static final int SKEW = 38;
private static final char DELIMITER = '-';
public static final String PUNY_CODE_PREFIX = "xn--";
private static final String PUNY_CODE_PREFIX = "xn--";
/**
* 将域名编码为PunyCode，会忽略"."的编码
@ -36,7 +36,7 @@ public class PunyCode {
*/
public static String encodeDomain(final String domain) throws UtilException {
Assert.notNull(domain, "domain must not be null!");
final List<String> split = StrUtil.split(domain, CharUtil.DOT);
final List<String> split = SplitUtil.split(domain, StrUtil.DOT);
final StringBuilder result = new StringBuilder(domain.length() * 4);
for (final String str : split) {
if (result.length() != 0) {
@ -156,7 +156,7 @@ public class PunyCode {
*/
public static String decodeDomain(final String domain) throws UtilException {
Assert.notNull(domain, "domain must not be null!");
final List<String> split = StrUtil.split(domain, CharUtil.DOT);
final List<String> split = SplitUtil.split(domain, StrUtil.DOT);
final StringBuilder result = new StringBuilder(domain.length() / 4 + 1);
for (final String str : split) {
if (result.length() != 0) {

36
hutool-core/src/main/java/cn/hutool/core/collection/CollUtil.java
View File

@ -19,43 +19,17 @@ import cn.hutool.core.reflect.FieldUtil;
import cn.hutool.core.reflect.TypeUtil;
import cn.hutool.core.stream.StreamUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.ObjUtil;
import java.lang.reflect.Type;
import java.util.AbstractCollection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.EnumSet;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.Map.Entry;
import java.util.NavigableSet;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.SortedSet;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
import java.util.function.*;
import java.util.stream.Collectors;
/**
@ -1350,7 +1324,7 @@ public class CollUtil {
* @since 3.0.4
*/
public static Map<String, String> zip(final String keys, final String values, final String delimiter, final boolean isOrder) {
return ArrayUtil.zip(StrUtil.splitToArray(keys, delimiter), StrUtil.splitToArray(values, delimiter), isOrder);
return ArrayUtil.zip(SplitUtil.splitToArray(keys, delimiter), SplitUtil.splitToArray(values, delimiter), isOrder);
}
/**
@ -1550,7 +1524,7 @@ public class CollUtil {
if (value instanceof CharSequence) {
// String按照逗号分隔的列表对待
final String arrayStr = StrUtil.unWrap((CharSequence) value, '[', ']');
iter = StrUtil.splitTrim(arrayStr, CharUtil.COMMA).iterator();
iter = SplitUtil.splitTrim(arrayStr, StrUtil.COMMA).iterator();
} else {
iter = IterUtil.getIter(value);
}

8
hutool-core/src/main/java/cn/hutool/core/comparator/VersionComparator.java
View File

@ -1,8 +1,8 @@
package cn.hutool.core.comparator;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.ObjUtil;
import java.io.Serializable;
import java.util.Comparator;
@ -61,8 +61,8 @@ public class VersionComparator implements Comparator<String>, Serializable {
return 1;
}
final List<String> v1s = StrUtil.split(version1, CharUtil.DOT);
final List<String> v2s = StrUtil.split(version2, CharUtil.DOT);
final List<String> v1s = SplitUtil.splitTrim(version1, StrUtil.DOT);
final List<String> v2s = SplitUtil.splitTrim(version2, StrUtil.DOT);
int diff = 0;
final int minLength = Math.min(v1s.size(), v2s.size());// 取最小长度值

4
hutool-core/src/main/java/cn/hutool/core/convert/impl/ArrayConverter.java
View File

@ -6,9 +6,9 @@ import cn.hutool.core.convert.AbstractConverter;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.io.SerializeUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ByteUtil;
import cn.hutool.core.util.CharUtil;
import java.io.Serializable;
import java.lang.reflect.Array;
@ -122,7 +122,7 @@ public class ArrayConverter extends AbstractConverter {
}
// 单纯字符串情况下按照逗号分隔后劈开
final String[] strings = StrUtil.splitToArray(value.toString(), CharUtil.COMMA);
final String[] strings = SplitUtil.splitToArray(value.toString(), StrUtil.COMMA);
return convertArrayToArray(targetComponentType, strings);
}

11
hutool-core/src/main/java/cn/hutool/core/date/DateUtil.java
View File

@ -11,7 +11,7 @@ import cn.hutool.core.math.NumberUtil;
import cn.hutool.core.regex.PatternPool;
import cn.hutool.core.regex.ReUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.text.split.SplitUtil;
import javax.xml.datatype.XMLGregorianCalendar;
import java.text.DateFormat;
@ -502,6 +502,7 @@ public class DateUtil extends CalendarUtil {
}
// region ----- format
/**
* 格式化日期时间<br>
* 格式 yyyy-MM-dd HH:mm:ss
@ -673,6 +674,7 @@ public class DateUtil extends CalendarUtil {
// endregion
// region ----- parse
/**
* 构建DateTime对象
*
@ -829,6 +831,7 @@ public class DateUtil extends CalendarUtil {
// endregion
// region ----- offset
/**
* 修改日期为某个时间字段起始时间
*
@ -1217,6 +1220,7 @@ public class DateUtil extends CalendarUtil {
// endregion
// region ----- between
/**
* 判断两个日期相差的时长，只保留绝对值
*
@ -1325,6 +1329,7 @@ public class DateUtil extends CalendarUtil {
// endregion
// region ----- formatBetween
/**
* 格式化日期间隔输出
*
@ -1626,7 +1631,7 @@ public class DateUtil extends CalendarUtil {
return 0;
}
final List<String> hms = StrUtil.splitTrim(timeStr, CharUtil.COLON, 3);
final List<String> hms = SplitUtil.split(timeStr, StrUtil.COLON, 3, true, true);
final int lastIndex = hms.size() - 1;
int result = 0;
@ -2071,7 +2076,7 @@ public class DateUtil extends CalendarUtil {
}
// 日期时间分开处理
final List<String> dateAndTime = StrUtil.splitTrim(dateStr, ' ');
final List<String> dateAndTime = SplitUtil.splitTrim(dateStr, StrUtil.SPACE);
final int size = dateAndTime.size();
if (size < 1 || size > 2) {
// 非可被标准处理的格式

3
hutool-core/src/main/java/cn/hutool/core/io/file/FileNameUtil.java
View File

@ -4,6 +4,7 @@ import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.net.url.URLUtil;
import cn.hutool.core.regex.ReUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.SystemUtil;
@ -387,7 +388,7 @@ public class FileNameUtil {
pathToUse = pathToUse.substring(1);
}
final List<String> pathList = StrUtil.split(pathToUse, CharUtil.SLASH);
final List<String> pathList = SplitUtil.split(pathToUse, StrUtil.SLASH);
final List<String> pathElements = new LinkedList<>();
int tops = 0;

5
hutool-core/src/main/java/cn/hutool/core/io/file/FileUtil.java
View File

@ -14,6 +14,7 @@ import cn.hutool.core.net.url.URLUtil;
import cn.hutool.core.reflect.ClassUtil;
import cn.hutool.core.regex.ReUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.*;
@ -2973,13 +2974,13 @@ public class FileUtil extends PathUtil {
*/
private static File buildFile(File outFile, String fileName) {
// 替换Windows路径分隔符为Linux路径分隔符，便于统一处理
fileName = fileName.replace('\\', '/');
fileName = fileName.replace(CharUtil.BACKSLASH, CharUtil.SLASH);
if (false == isWindows()
// 检查文件名中是否包含"/"，不考虑以"/"结尾的情况
&& fileName.lastIndexOf(CharUtil.SLASH, fileName.length() - 2) > 0) {
// 在Linux下多层目录创建存在问题，/会被当成文件名的一部分，此处做处理
// 使用/拆分路径（zip中无\），级联创建父目录
final List<String> pathParts = StrUtil.split(fileName, '/', false, true);
final List<String> pathParts = SplitUtil.split(fileName, StrUtil.SLASH, false, true);
final int lastPartIndex = pathParts.size() - 1;//目录个数
for (int i = 0; i < lastPartIndex; i++) {
//由于路径拆分，slip不检查，在最后一步检查

4
hutool-core/src/main/java/cn/hutool/core/net/Ipv4Pool.java
View File

@ -1,5 +1,7 @@
package cn.hutool.core.net;
import cn.hutool.core.text.StrUtil;
/**
* Ip相关常量
* <pre>
@ -23,7 +25,7 @@ public interface Ipv4Pool {
/**
* IP与掩码的分割符
*/
String IP_MASK_SPLIT_MARK = "/";
String IP_MASK_SPLIT_MARK = StrUtil.SLASH;
/**
* localhost默认解析的ip地址

5
hutool-core/src/main/java/cn/hutool/core/net/Ipv4Util.java
View File

@ -4,6 +4,7 @@ import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.regex.PatternPool;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.CharUtil;
import java.util.ArrayList;
@ -54,11 +55,11 @@ public class Ipv4Util implements Ipv4Pool {
public static List<String> list(final String ipRange, final boolean isAll) {
if (ipRange.contains(IP_SPLIT_MARK)) {
// X.X.X.X-X.X.X.X
final String[] range = StrUtil.splitToArray(ipRange, IP_SPLIT_MARK);
final String[] range = SplitUtil.splitToArray(ipRange, IP_SPLIT_MARK);
return list(range[0], range[1]);
} else if (ipRange.contains(IP_MASK_SPLIT_MARK)) {
// X.X.X.X/X
final String[] param = StrUtil.splitToArray(ipRange, IP_MASK_SPLIT_MARK);
final String[] param = SplitUtil.splitToArray(ipRange, IP_MASK_SPLIT_MARK);
return list(param[0], Integer.parseInt(param[1]), isAll);
} else {
return ListUtil.of(ipRange);

6
hutool-core/src/main/java/cn/hutool/core/net/NetUtil.java
View File

@ -6,6 +6,8 @@ import cn.hutool.core.exceptions.UtilException;
import cn.hutool.core.io.IORuntimeException;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.JNDIUtil;
import cn.hutool.core.util.RandomUtil;
@ -744,8 +746,8 @@ public class NetUtil {
*/
public static String getMultistageReverseProxyIp(String ip) {
// 多级反向代理检测
if (ip != null && StrUtil.indexOf(ip, ',') > 0) {
final List<String> ips = StrUtil.splitTrim(ip, ',');
if (ip != null && StrUtil.indexOf(ip, CharUtil.COMMA) > 0) {
final List<String> ips = SplitUtil.splitTrim(ip, StrUtil.COMMA);
for (final String subIp : ips) {
if (false == isUnknown(subIp)) {
ip = subIp;

3
hutool-core/src/main/java/cn/hutool/core/net/url/UrlPath.java
View File

@ -3,6 +3,7 @@ package cn.hutool.core.net.url;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.util.ObjUtil;
@ -114,7 +115,7 @@ public class UrlPath {
path = fixPath(path);
if (StrUtil.isNotEmpty(path)) {
final List<String> split = StrUtil.split(path, '/');
final List<String> split = SplitUtil.split(path, StrUtil.SLASH);
for (final String seg : split) {
addInternal(URLDecoder.decodeForPath(seg, charset), false);
}

3
hutool-core/src/main/java/cn/hutool/core/reflect/ClassUtil.java
View File

@ -9,6 +9,7 @@ import cn.hutool.core.io.resource.ResourceUtil;
import cn.hutool.core.net.url.URLDecoder;
import cn.hutool.core.net.url.URLUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.CharsetUtil;
@ -121,7 +122,7 @@ public class ClassUtil {
* @since 4.1.9
*/
public static String getShortClassName(final String className) {
final List<String> packages = StrUtil.split(className, CharUtil.DOT);
final List<String> packages = SplitUtil.split(className, StrUtil.DOT);
if (null == packages || packages.size() < 2) {
return className;
}

3
hutool-core/src/main/java/cn/hutool/core/text/AntPathMatcher.java
View File

@ -424,7 +424,8 @@ public class AntPathMatcher {
* @return the tokenized path parts
*/
protected String[] tokenizePath(final String path) {
return SplitUtil.splitToArray(path, this.pathSeparator, 0, this.trimTokens, true);
return SplitUtil.split(path, this.pathSeparator, this.trimTokens, true)
.toArray(new String[0]);
}
/**

350
hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java
View File

@ -2,7 +2,6 @@ package cn.hutool.core.text;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.comparator.VersionComparator;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.lang.func.SerFunction;
import cn.hutool.core.math.NumberUtil;
@ -1012,19 +1011,7 @@ public class CharSequenceUtil extends StrChecker {
if (null == str || ArrayUtil.isEmpty(chars)) {
return str(str);
}
final int len = str.length();
if (0 == len) {
return str(str);
}
final StringBuilder builder = new StringBuilder(len);
char c;
for (int i = 0; i < len; i++) {
c = str.charAt(i);
if (false == ArrayUtil.contains(chars, c)) {
builder.append(c);
}
}
return builder.toString();
return filter(str, (c)-> false == ArrayUtil.contains(chars, c));
}
/**
@ -1288,270 +1275,6 @@ public class CharSequenceUtil extends StrChecker {
}
// endregion
// region ----- split
/**
* 切分字符串为long数组
*
* @param str 被切分的字符串
* @param separator 分隔符
* @return 切分后long数组
* @since 4.0.6
*/
public static long[] splitToLong(final CharSequence str, final char separator) {
return Convert.convert(long[].class, splitTrim(str, separator));
}
/**
* 切分字符串为long数组
*
* @param str 被切分的字符串
* @param separator 分隔符字符串
* @return 切分后long数组
* @since 4.0.6
*/
public static long[] splitToLong(final CharSequence str, final CharSequence separator) {
return Convert.convert(long[].class, splitTrim(str, separator));
}
/**
* 切分字符串为int数组
*
* @param str 被切分的字符串
* @param separator 分隔符
* @return 切分后long数组
* @since 4.0.6
*/
public static int[] splitToInt(final CharSequence str, final char separator) {
return Convert.convert(int[].class, splitTrim(str, separator));
}
/**
* 切分字符串为int数组
*
* @param str 被切分的字符串
* @param separator 分隔符字符串
* @return 切分后long数组
* @since 4.0.6
*/
public static int[] splitToInt(final CharSequence str, final CharSequence separator) {
return Convert.convert(int[].class, splitTrim(str, separator));
}
/**
* 切分字符串<br>
* a#b#c =》 [a,b,c] <br>
* a##b#c =》 [a,"",b,c]
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @return 切分后的集合
*/
public static List<String> split(final CharSequence str, final char separator) {
return split(str, separator, 0);
}
/**
* 切分字符串，如果分隔符不存在则返回原字符串
*
* @param str 被切分的字符串
* @param separator 分隔符
* @return 字符串
* @since 5.6.7
*/
public static String[] splitToArray(final CharSequence str, final CharSequence separator) {
if (str == null) {
return new String[]{};
}
return SplitUtil.splitToArray(str.toString(), str(separator), 0, false, false);
}
/**
* 切分字符串
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @return 切分后的数组
*/
public static String[] splitToArray(final CharSequence str, final char separator) {
return splitToArray(str, separator, 0);
}
/**
* 切分字符串
*
* @param text 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数
* @return 切分后的数组
*/
public static String[] splitToArray(final CharSequence text, final char separator, final int limit) {
Assert.notNull(text, "Text must be not null!");
return SplitUtil.splitToArray(text.toString(), separator, limit, false, false);
}
/**
* 切分字符串，不去除切分后每个元素两边的空白符，不去除空白项
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，-1不限制
* @return 切分后的集合
*/
public static List<String> split(final CharSequence str, final char separator, final int limit) {
return split(str, separator, limit, false, false);
}
/**
* 切分字符串，去除切分后每个元素两边的空白符，去除空白项
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @return 切分后的集合
* @since 3.1.2
*/
public static List<String> splitTrim(final CharSequence str, final char separator) {
return splitTrim(str, separator, -1);
}
/**
* 切分字符串，去除切分后每个元素两边的空白符，去除空白项
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @return 切分后的集合
* @since 3.2.0
*/
public static List<String> splitTrim(final CharSequence str, final CharSequence separator) {
return splitTrim(str, separator, -1);
}
/**
* 切分字符串，去除切分后每个元素两边的空白符，去除空白项
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，-1不限制
* @return 切分后的集合
* @since 3.1.0
*/
public static List<String> splitTrim(final CharSequence str, final char separator, final int limit) {
return split(str, separator, limit, true, true);
}
/**
* 切分字符串，去除切分后每个元素两边的空白符，去除空白项
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，-1不限制
* @return 切分后的集合
* @since 3.2.0
*/
public static List<String> splitTrim(final CharSequence str, final CharSequence separator, final int limit) {
return split(str, separator, limit, true, true);
}
/**
* 切分字符串，不限制分片数量
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static List<String> split(final CharSequence str, final char separator, final boolean isTrim, final boolean ignoreEmpty) {
return split(str, separator, 0, isTrim, ignoreEmpty);
}
/**
* 切分字符串
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，-1不限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static List<String> split(final CharSequence str, final char separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
return SplitUtil.split(str, separator, limit, isTrim, ignoreEmpty);
}
/**
* 切分字符串
*
* @param <R> 切分后元素类型
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，-1不限制
* @param ignoreEmpty 是否忽略空串
* @param mapping 切分后的字符串元素的转换方法
* @return 切分后的集合，元素类型是经过 mapping 转换后的
* @since 5.7.14
*/
public static <R> List<R> split(final CharSequence str, final char separator, final int limit, final boolean ignoreEmpty, final Function<String, R> mapping) {
return SplitUtil.split(str, separator, limit, ignoreEmpty, mapping);
}
/**
* 切分字符串，如果分隔符不存在则返回原字符串
*
* @param str 被切分的字符串
* @param separator 分隔符
* @return 字符串
* @since 5.7.1
*/
public static List<String> split(final CharSequence str, final CharSequence separator) {
return split(str, separator, false, false);
}
/**
* 切分字符串
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 5.6.7
*/
public static List<String> split(final CharSequence str, final CharSequence separator, final boolean isTrim, final boolean ignoreEmpty) {
return split(str, separator, 0, isTrim, ignoreEmpty);
}
/**
* 切分字符串
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，-1不限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.0
*/
public static List<String> split(final CharSequence str, final CharSequence separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
final String separatorStr = (null == separator) ? null : separator.toString();
return SplitUtil.split(str, separatorStr, limit, isTrim, ignoreEmpty);
}
/**
* 根据给定长度，将给定字符串截取为多个部分
*
* @param str 字符串
* @param len 每一个小节的长度
* @return 截取后的字符串数组
* @see SplitUtil#splitByLength(CharSequence, int)
*/
public static String[] splitToArray(final CharSequence str, final int len) {
return SplitUtil.splitByLength(str, len);
}
/**
* 将字符串切分为N等份
*
@ -1577,7 +1300,6 @@ public class CharSequenceUtil extends StrChecker {
}
return array;
}
// endregion
// region ----- sub
@ -2044,7 +1766,7 @@ public class CharSequenceUtil extends StrChecker {
}
final List<String> result = new LinkedList<>();
final String[] split = splitToArray(str, prefix);
final String[] split = SplitUtil.splitToArray(str, prefix);
if (prefix.equals(suffix)) {
// 前后缀字符相同，单独处理
for (int i = 1, length = split.length - 1; i < length; i += 2) {
@ -2112,12 +1834,7 @@ public class CharSequenceUtil extends StrChecker {
if (count <= 0) {
return EMPTY;
}
final char[] result = new char[count];
for (int i = 0; i < count; i++) {
result[i] = c;
}
return new String(result);
return StrRepeater.of(count).repeat(c);
}
/**
@ -2131,33 +1848,15 @@ public class CharSequenceUtil extends StrChecker {
if (null == str) {
return null;
}
if (count <= 0 || str.length() == 0) {
return EMPTY;
}
if (count == 1) {
return str.toString();
}
// 检查
final int len = str.length();
final long longSize = (long) len * (long) count;
final int size = (int) longSize;
if (size != longSize) {
throw new ArrayIndexOutOfBoundsException("Required String length is too large: " + longSize);
}
final char[] array = new char[size];
str.toString().getChars(0, len, array, 0);
int n;
for (n = len; n < size - n; n <<= 1) {// n <<= 1相当于n *2
System.arraycopy(array, 0, array, n, n);
}
System.arraycopy(array, 0, array, n, size - n);
return new String(array);
return StrRepeater.of(count).repeat(str);
}
/**
* 重复某个字符串到指定长度
* <ul>
* <li>如果指定长度非指定字符串的整数倍，截断到固定长度</li>
* <li>如果指定长度小于字符串本身的长度，截断之</li>
* </ul>
*
* @param str 被重复的字符
* @param padLen 指定长度
@ -2171,19 +1870,7 @@ public class CharSequenceUtil extends StrChecker {
if (padLen <= 0) {
return EMPTY;
}
final int strLen = str.length();
if (strLen == padLen) {
return str.toString();
} else if (strLen > padLen) {
return subPre(str, padLen);
}
// 重复，直到达到指定长度
final char[] padding = new char[padLen];
for (int i = 0; i < padLen; i++) {
padding[i] = str.charAt(i % strLen);
}
return new String(padding);
return StrRepeater.of(padLen).repeatByLength(str);
}
/**
@ -2201,22 +1888,11 @@ public class CharSequenceUtil extends StrChecker {
* @return 连接后的字符串
* @since 4.0.1
*/
public static String repeatAndJoin(final CharSequence str, int count, final CharSequence delimiter) {
public static String repeatAndJoin(final CharSequence str, final int count, final CharSequence delimiter) {
if (count <= 0) {
return EMPTY;
}
final StringBuilder builder = new StringBuilder(str.length() * count);
builder.append(str);
count--;
final boolean isAppendDelimiter = isNotEmpty(delimiter);
while (count-- > 0) {
if (isAppendDelimiter) {
builder.append(delimiter);
}
builder.append(str);
}
return builder.toString();
return StrRepeater.of(count).repeatAndJoin(str, delimiter);
}
// endregion
@ -2368,8 +2044,8 @@ public class CharSequenceUtil extends StrChecker {
* @param str2 第二个字符串
* @param ignoreCase 是否忽略大小写
* @return 子串是否相同
* @since 3.2.1
* @see String#regionMatches(boolean, int, String, int, int)
* @since 3.2.1
*/
public static boolean isSubEquals(final CharSequence str1, final int start1,
final CharSequence str2, final boolean ignoreCase) {
@ -2387,8 +2063,8 @@ public class CharSequenceUtil extends StrChecker {
* @param length 截取长度
* @param ignoreCase 是否忽略大小写
* @return 子串是否相同
* @since 3.2.1
* @see String#regionMatches(boolean, int, String, int, int)
* @since 3.2.1
*/
public static boolean isSubEquals(final CharSequence str1, final int start1,
final CharSequence str2, final int start2, final int length,

5
hutool-core/src/main/java/cn/hutool/core/text/StrEditor.java
View File

@ -1,5 +0,0 @@
package cn.hutool.core.text;
public class StrEditor {
private
}

164
hutool-core/src/main/java/cn/hutool/core/text/StrRepeater.java Normal file
View File

@ -0,0 +1,164 @@
package cn.hutool.core.text;
/**
* 字符串或字符重复器<br>
* 用于将给定字符串或字符赋值count次，然后拼接
*
* @author looly
* @since 6.0.0
*/
public class StrRepeater {
private final int countOrLength;
/**
* 创建StrRepeater
*
* @param countOrLength 重复次数或固定长度
* @return StrRepeater
*/
public static StrRepeater of(final int countOrLength) {
return new StrRepeater(countOrLength);
}
/**
* 构造
*
* @param countOrLength 重复次数或固定长度
*/
public StrRepeater(final int countOrLength) {
this.countOrLength = countOrLength;
}
/**
* 重复某个字符
*
* <pre>
* repeat('e', 0) = ""
* repeat('e', 3) = "eee"
* repeat('e', -2) = ""
* </pre>
*
* @param c 被重复的字符
* @return 重复字符字符串
*/
public String repeat(final char c) {
final int count = this.countOrLength;
if (count <= 0) {
return StrUtil.EMPTY;
}
final char[] result = new char[count];
for (int i = 0; i < count; i++) {
result[i] = c;
}
return new String(result);
}
/**
* 重复某个字符串
*
* @param str 被重复的字符
* @return 重复字符字符串
*/
public String repeat(final CharSequence str) {
if (null == str) {
return null;
}
final int count = this.countOrLength;
if (count <= 0 || str.length() == 0) {
return StrUtil.EMPTY;
}
if (count == 1) {
return str.toString();
}
// 检查
final int len = str.length();
final long longSize = (long) len * (long) count;
final int size = (int) longSize;
if (size != longSize) {
throw new ArrayIndexOutOfBoundsException("Required String length is too large: " + longSize);
}
// 相比使用StringBuilder更高效
final char[] array = new char[size];
str.toString().getChars(0, len, array, 0);
int n;
for (n = len; n < size - n; n <<= 1) {// n <<= 1相当于n *2
System.arraycopy(array, 0, array, n, n);
}
System.arraycopy(array, 0, array, n, size - n);
return new String(array);
}
/**
* 重复某个字符串到指定长度
* <ul>
* <li>如果指定长度非指定字符串的整数倍，截断到固定长度</li>
* <li>如果指定长度小于字符串本身的长度，截断之</li>
* </ul>
*
* @param str 被重复的字符
* @return 重复字符字符串
* @since 4.3.2
*/
public String repeatByLength(final CharSequence str) {
if (null == str) {
return null;
}
final int padLen = this.countOrLength;
if (padLen <= 0) {
return StrUtil.EMPTY;
}
final int strLen = str.length();
if (strLen == padLen) {
return str.toString();
} else if (strLen > padLen) {
return StrUtil.subPre(str, padLen);
}
// 重复，直到达到指定长度
final char[] padding = new char[padLen];
for (int i = 0; i < padLen; i++) {
padding[i] = str.charAt(i % strLen);
}
return new String(padding);
}
/**
* 重复某个字符串并通过分界符连接
*
* <pre>
* repeatAndJoin("?", 5, ",") = "?,?,?,?,?"
* repeatAndJoin("?", 0, ",") = ""
* repeatAndJoin("?", 5, null) = "?????"
* </pre>
*
* @param str 被重复的字符串
* @param delimiter 分界符
* @return 连接后的字符串
* @since 4.0.1
*/
public String repeatAndJoin(final CharSequence str, final CharSequence delimiter) {
int count = this.countOrLength;
if (count <= 0) {
return StrUtil.EMPTY;
}
if(StrUtil.isEmpty(delimiter)){
return repeat(str);
}
// 初始大小 = 所有重复字符串长度 + 分界符总长度
final StringBuilder builder = new StringBuilder(
str.length() * count + delimiter.length() * (count - 1));
builder.append(str);
count--;
while (count-- > 0) {
builder.append(delimiter).append(str);
}
return builder.toString();
}
}

13
hutool-core/src/main/java/cn/hutool/core/text/dfa/SensitiveUtil.java
View File

@ -1,9 +1,9 @@
package cn.hutool.core.text.dfa;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.thread.ThreadUtil;
import java.util.Collection;
import java.util.HashMap;
@ -18,7 +18,10 @@ import java.util.function.Predicate;
*/
public final class SensitiveUtil {
public static final char DEFAULT_SEPARATOR = CharUtil.COMMA;
/**
* 默认关键词分隔符
*/
public static final String DEFAULT_SEPARATOR = StrUtil.COMMA;
private static final WordTree sensitiveTree = new WordTree();
/**
@ -63,9 +66,9 @@ public final class SensitiveUtil {
* @param isAsync 是否异步初始化
* @param separator 分隔符
*/
public static void init(final String sensitiveWords, final char separator, final boolean isAsync) {
public static void init(final String sensitiveWords, final String separator, final boolean isAsync) {
if (StrUtil.isNotBlank(sensitiveWords)) {
init(StrUtil.split(sensitiveWords, separator), isAsync);
init(SplitUtil.split(sensitiveWords, separator), isAsync);
}
}

435
hutool-core/src/main/java/cn/hutool/core/text/split/SplitUtil.java
View File

@ -1,13 +1,11 @@
package cn.hutool.core.text.split;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.regex.PatternPool;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.finder.CharFinder;
import cn.hutool.core.text.finder.CharMatcherFinder;
import cn.hutool.core.text.finder.LengthFinder;
import cn.hutool.core.text.finder.PatternFinder;
import cn.hutool.core.text.finder.StrFinder;
import cn.hutool.core.text.finder.*;
import cn.hutool.core.util.CharUtil;
import java.util.ArrayList;
@ -17,205 +15,74 @@ import java.util.regex.Pattern;
/**
* 字符串切分器，封装统一的字符串分割静态方法
*
* @author Looly
* @since 5.7.0
*/
public class SplitUtil {
//---------------------------------------------------------------------------------------------- Split by char
/**
* 无限制切分个数
*/
public static int UNLIMITED = -1;
// region ----- split to
/**
* 切分字符串路径，仅支持Unix分界符：/
* <p>去除每个元素两边空格，大小写敏感，忽略空串</p>
* 切分字符串，去除切分后每个元素两边的空白符，去除空白项，并转为结果类型
*
* @param str 被切分的字符串
* @param <T> 结果类型
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param resultType 结果类型的类，可以是数组或集合
* @return long数组
*/
public static <T> T splitTo(final CharSequence str, final CharSequence separator, final Class<T> resultType) {
return Convert.convert(resultType, splitTrim(str, separator));
}
// endregion
// region ----- Split by String or char
/**
* 切分字符串，去除切分后每个元素两边的空白符，去除空白项
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @return 切分后的集合
* @since 3.0.8
* @since 3.2.0
*/
public static List<String> splitPath(final CharSequence str) {
return splitPath(str, 0);
public static List<String> splitTrim(final CharSequence str, final CharSequence separator) {
return split(str, separator, true, true);
}
/**
* 切分字符串路径，仅支持Unix分界符：/
* <p>去除每个元素两边空格，大小写敏感，忽略空串</p>
* 切分字符串，如果分隔符不存在则返回原字符串<br>
* 此方法不会去除切分字符串后每个元素两边的空格，不忽略空串
*
* @param str 被切分的字符串
* @return 切分后的集合
* @since 3.0.8
* @param str 被切分的字符串
* @param separator 分隔符
* @return 字符串
*/
public static String[] splitPathToArray(final CharSequence str) {
return toArray(splitPath(str));
}
/**
* 切分字符串路径，仅支持Unix分界符：/
* <p>去除每个元素两边空格，大小写敏感，忽略空串</p>
*
* @param str 被切分的字符串
* @param limit 限制分片数，小于等于0表示无限制
* @return 切分后的集合
* @since 3.0.8
*/
public static List<String> splitPath(final CharSequence str, final int limit) {
return split(str, CharUtil.SLASH, limit, true, true);
}
/**
* 切分字符串路径，仅支持Unix分界符：/
* <p>去除每个元素两边空格，大小写敏感，忽略空串</p>
*
* @param str 被切分的字符串
* @param limit 限制分片数，小于等于0表示无限制
* @return 切分后的集合
* @since 3.0.8
*/
public static String[] splitPathToArray(final CharSequence str, final int limit) {
return toArray(splitPath(str, limit));
}
/**
* 切分字符串，大小写敏感，去除每个元素两边空白符
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
public static List<String> splitTrim(final CharSequence str, final char separator, final boolean ignoreEmpty) {
return split(str, separator, 0, true, ignoreEmpty);
}
/**
* 切分字符串
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static List<String> split(final CharSequence str, final char separator, final boolean isTrim, final boolean ignoreEmpty) {
return split(str, separator, 0, isTrim, ignoreEmpty);
}
/**
* 切分字符串，大小写敏感，去除每个元素两边空白符
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，小于等于0表示无限制
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static List<String> splitTrim(final CharSequence str, final char separator, final int limit, final boolean ignoreEmpty) {
return split(str, separator, limit, true, ignoreEmpty, false);
}
/**
* 切分字符串，大小写敏感
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，小于等于0表示无限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static List<String> split(final CharSequence str, final char separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
return split(str, separator, limit, isTrim, ignoreEmpty, false);
}
/**
* 切分字符串，大小写敏感
*
* @param <R> 切分后的元素类型
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，小于等于0表示无限制
* @param ignoreEmpty 是否忽略空串
* @param mapping 切分后的字符串元素的转换方法
* @return 切分后的集合，元素类型是经过 mapping 转换后的
* @since 5.7.14
*/
public static <R> List<R> split(final CharSequence str, final char separator, final int limit, final boolean ignoreEmpty, final Function<String, R> mapping) {
return split(str, separator, limit, ignoreEmpty, false, mapping);
}
/**
* 切分字符串，忽略大小写
*
* @param text 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，小于等于0表示无限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
public static List<String> splitIgnoreCase(final CharSequence text, final char separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
return split(text, separator, limit, isTrim, ignoreEmpty, true);
}
/**
* 切分字符串
*
* @param text 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，小于等于0表示无限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @param ignoreCase 是否忽略大小写
* @return 切分后的集合
*/
public static List<String> split(final CharSequence text, final char separator, final int limit, final boolean isTrim, final boolean ignoreEmpty, final boolean ignoreCase) {
return split(text, separator, limit, ignoreEmpty, ignoreCase, trimFunc(isTrim));
}
/**
* 切分字符串<br>
* 如果为空字符串或者null 则返回空集合
*
* @param <R> 切分后的元素类型
* @param text 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，小于等于0表示无限制
* @param ignoreEmpty 是否忽略空串
* @param ignoreCase 是否忽略大小写
* @param mapping 切分后的字符串元素的转换方法
* @return 切分后的集合，元素类型是经过 mapping 转换后的
* @since 5.7.14
*/
public static <R> List<R> split(final CharSequence text, final char separator, final int limit, final boolean ignoreEmpty,
final boolean ignoreCase, final Function<String, R> mapping) {
if (StrUtil.isEmpty(text)) {
return new ArrayList<>(0);
public static String[] splitToArray(final CharSequence str, final CharSequence separator) {
if (str == null) {
return new String[]{};
}
final SplitIter splitIter = new SplitIter(text, new CharFinder(separator, ignoreCase), limit, ignoreEmpty);
return splitIter.toList(mapping);
return toArray(split(str, separator));
}
/**
* 切分字符串为字符串数组
* 切分字符串，如果分隔符不存在则返回原字符串<br>
* 此方法不会去除切分字符串后每个元素两边的空格，不忽略空串
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，小于等于0表示无限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
* @param str 被切分的字符串
* @param separator 分隔符
* @return 字符串
*/
public static String[] splitToArray(final CharSequence str, final char separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
return toArray(split(str, separator, limit, isTrim, ignoreEmpty));
public static List<String> split(final CharSequence str, final CharSequence separator) {
return split(str, separator, false, false);
}
//---------------------------------------------------------------------------------------------- Split by String
/**
* 切分字符串，不忽略大小写
*
@ -226,21 +93,9 @@ public class SplitUtil {
* @return 切分后的集合
* @since 3.0.8
*/
public static List<String> split(final CharSequence str, final String separator, final boolean isTrim, final boolean ignoreEmpty) {
return split(str, separator, -1, isTrim, ignoreEmpty, false);
}
/**
* 切分字符串，去除每个元素两边空格，不忽略大小写
*
* @param str 被切分的字符串
* @param separator 分隔符字符串
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
public static List<String> splitTrim(final CharSequence str, final String separator, final boolean ignoreEmpty) {
return split(str, separator, true, ignoreEmpty);
public static List<String> split(final CharSequence str, final CharSequence separator,
final boolean isTrim, final boolean ignoreEmpty) {
return split(str, separator, UNLIMITED, isTrim, ignoreEmpty, false);
}
/**
@ -254,109 +109,127 @@ public class SplitUtil {
* @return 切分后的集合
* @since 3.0.8
*/
public static List<String> split(final CharSequence str, final String separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
public static List<String> split(final CharSequence str, final CharSequence separator,
final int limit, final boolean isTrim, final boolean ignoreEmpty) {
return split(str, separator, limit, isTrim, ignoreEmpty, false);
}
/**
* 切分字符串，去除每个元素两边空格，不忽略大小写
*
* @param str 被切分的字符串
* @param separator 分隔符字符串
* @param limit 限制分片数，小于等于0表示无限制
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
public static List<String> splitTrim(final CharSequence str, final String separator, final int limit, final boolean ignoreEmpty) {
return split(str, separator, limit, true, ignoreEmpty);
}
/**
* 切分字符串，忽略大小写
*
* @param str 被切分的字符串
* @param separator 分隔符字符串
* @param limit 限制分片数，小于等于0表示无限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
public static List<String> splitIgnoreCase(final CharSequence str, final String separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
return split(str, separator, limit, isTrim, ignoreEmpty, true);
}
/**
* 切分字符串，去除每个元素两边空格，忽略大小写
*
* @param str 被切分的字符串
* @param separator 分隔符字符串
* @param limit 限制分片数，小于等于0表示无限制
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
public static List<String> splitTrimIgnoreCase(final CharSequence str, final String separator, final int limit, final boolean ignoreEmpty) {
return split(str, separator, limit, true, ignoreEmpty, true);
}
/**
* 切分字符串<br>
* 如果提供的字符串为{@code null}，则返回一个空的{@link ArrayList}<br>
* 如果提供的字符串为""，则当ignoreEmpty时返回空的{@link ArrayList}，否则返回只有一个""元素的{@link ArrayList}
*
* @param text 被切分的字符串
* @param str 被切分的字符串
* @param separator 分隔符字符串
* @param limit 限制分片数，小于等于0表示无限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @param ignoreCase 是否忽略大小写
* @return 切分后的集合
* @since 3.2.1
*/
public static List<String> split(final CharSequence text, final String separator, final int limit, final boolean isTrim, final boolean ignoreEmpty, final boolean ignoreCase) {
if(null == text){
return new ArrayList<>(0);
} else if (0 == text.length()) {
return ignoreEmpty ? new ArrayList<>(0) : ListUtil.of(StrUtil.EMPTY);
}
final SplitIter splitIter = new SplitIter(text, StrFinder.of(separator, ignoreCase), limit, ignoreEmpty);
return splitIter.toList(isTrim);
public static List<String> split(final CharSequence str, final CharSequence separator,
final int limit, final boolean isTrim, final boolean ignoreEmpty, final boolean ignoreCase) {
return split(str, separator, limit, ignoreEmpty, ignoreCase, trimFunc(isTrim));
}
/**
* 切分字符串为字符串数组
* 切分字符串<br>
* 如果提供的字符串为{@code null}，则返回一个空的{@link ArrayList}<br>
* 如果提供的字符串为""，则当ignoreEmpty时返回空的{@link ArrayList}，否则返回只有一个""元素的{@link ArrayList}
*
* @param <R> 元素类型
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param separator 分隔符字符串
* @param limit 限制分片数，小于等于0表示无限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @param ignoreCase 是否忽略大小写
* @param mapping 切分后字段映射函数
* @return 切分后的集合
*/
public static <R> List<R> split(final CharSequence str, final CharSequence separator,
final int limit, final boolean ignoreEmpty, final boolean ignoreCase,
final Function<String, R> mapping) {
if (null == str) {
return ListUtil.zero();
} else if (0 == str.length() && ignoreEmpty) {
return ListUtil.zero();
}
Assert.notEmpty(separator, "Separator must be not empty!");
// 查找分隔符的方式
final TextFinder finder = separator.length() == 1 ?
new CharFinder(separator.charAt(0), ignoreCase) :
StrFinder.of(separator, ignoreCase);
final SplitIter splitIter = new SplitIter(str, finder, limit, ignoreEmpty);
return splitIter.toList(mapping);
}
// endregion
// region ----- Split by XXX
/**
* 切分路径字符串<br>
* 如果为空字符串或者null 则返回空集合<br><br>
* 空路径会被忽略
*
* @param str 被切分的字符串
* @return 切分后的集合
*/
public static List<String> splitPath(final CharSequence str) {
return splitPath(str, UNLIMITED);
}
/**
* 切分路径字符串<br>
* 如果为空字符串或者null 则返回空集合<br>
* 空路径会被忽略
*
* @param str 被切分的字符串
* @param limit 限制分片数，小于等于0表示无限制
* @return 切分后的集合
* @since 3.0.8
*/
public static String[] splitToArray(final CharSequence str, final String separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
return toArray(split(str, separator, limit, isTrim, ignoreEmpty));
}
public static List<String> splitPath(final CharSequence str, final int limit) {
if (StrUtil.isBlank(str)) {
return ListUtil.zero();
}
//---------------------------------------------------------------------------------------------- Split by Whitespace
final SplitIter splitIter = new SplitIter(str,
new CharMatcherFinder(
(c) -> c == CharUtil.SLASH || c == CharUtil.BACKSLASH),
// 路径中允许空格
limit, true);
return splitIter.toList(false);
}
/**
* 使用空白符切分字符串<br>
* 切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一<br>
* 如果为空字符串或者null 则返回空集合
*
* @param text 被切分的字符串
* @param str 被切分的字符串
* @return 切分后的集合
*/
public static List<String> splitByBlank(final CharSequence str) {
return splitByBlank(str, UNLIMITED);
}
/**
* 使用空白符切分字符串<br>
* 切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一<br>
* 如果为空字符串或者null 则返回空集合
*
* @param str 被切分的字符串
* @param limit 限制分片数，小于等于0表示无限制
* @return 切分后的集合
* @since 3.0.8
*/
public static List<String> split(final CharSequence text, final int limit) {
if (StrUtil.isBlank(text)) {
return new ArrayList<>(0);
public static List<String> splitByBlank(final CharSequence str, final int limit) {
if (StrUtil.isBlank(str)) {
return ListUtil.zero();
}
final SplitIter splitIter = new SplitIter(text, new CharMatcherFinder(CharUtil::isBlankChar), limit, true);
final SplitIter splitIter = new SplitIter(str, new CharMatcherFinder(CharUtil::isBlankChar), limit, true);
return splitIter.toList(false);
}
@ -368,15 +241,14 @@ public class SplitUtil {
* @return 切分后的集合
* @since 3.0.8
*/
public static String[] splitToArray(final CharSequence str, final int limit) {
return toArray(split(str, limit));
public static String[] splitByBlankToArray(final CharSequence str, final int limit) {
return toArray(splitByBlank(str, limit));
}
//---------------------------------------------------------------------------------------------- Split by regex
/**
* 通过正则切分字符串
*
* @param text 字符串
* @param str 字符串
* @param separatorRegex 分隔符正则
* @param limit 限制分片数，小于等于0表示无限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
@ -384,16 +256,16 @@ public class SplitUtil {
* @return 切分后的集合
* @since 3.0.8
*/
public static List<String> splitByRegex(final CharSequence text, final String separatorRegex, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
public static List<String> splitByRegex(final CharSequence str, final String separatorRegex, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
final Pattern pattern = PatternPool.get(separatorRegex);
return split(text, pattern, limit, isTrim, ignoreEmpty);
return splitByRegex(str, pattern, limit, isTrim, ignoreEmpty);
}
/**
* 通过正则切分字符串<br>
* 如果为空字符串或者null 则返回空集合
*
* @param text 字符串
* @param str 字符串
* @param separatorPattern 分隔符正则{@link Pattern}
* @param limit 限制分片数，小于等于0表示无限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
@ -401,11 +273,11 @@ public class SplitUtil {
* @return 切分后的集合
* @since 3.0.8
*/
public static List<String> split(final CharSequence text, final Pattern separatorPattern, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
if (StrUtil.isEmpty(text)) {
return new ArrayList<>(0);
public static List<String> splitByRegex(final CharSequence str, final Pattern separatorPattern, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
if (StrUtil.isEmpty(str)) {
return ListUtil.zero();
}
final SplitIter splitIter = new SplitIter(text, new PatternFinder(separatorPattern), limit, ignoreEmpty);
final SplitIter splitIter = new SplitIter(str, new PatternFinder(separatorPattern), limit, ignoreEmpty);
return splitIter.toList(isTrim);
}
@ -420,26 +292,25 @@ public class SplitUtil {
* @return 切分后的集合
* @since 3.0.8
*/
public static String[] splitToArray(final CharSequence str, final Pattern separatorPattern, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
return toArray(split(str, separatorPattern, limit, isTrim, ignoreEmpty));
public static String[] splitByRegexToArray(final CharSequence str, final Pattern separatorPattern, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
return toArray(splitByRegex(str, separatorPattern, limit, isTrim, ignoreEmpty));
}
//---------------------------------------------------------------------------------------------- Split by length
/**
* 根据给定长度，将给定字符串截取为多个部分
*
* @param text 字符串
* @param len 每一个小节的长度，必须大于0
* @param str 字符串
* @param len 每一个小节的长度，必须大于0
* @return 截取后的字符串数组
*/
public static String[] splitByLength(final CharSequence text, final int len) {
if (StrUtil.isEmpty(text)) {
public static String[] splitByLength(final CharSequence str, final int len) {
if (StrUtil.isEmpty(str)) {
return new String[0];
}
final SplitIter splitIter = new SplitIter(text, new LengthFinder(len), -1, false);
final SplitIter splitIter = new SplitIter(str, new LengthFinder(len), -1, false);
return splitIter.toArray(false);
}
//---------------------------------------------------------------------------------------------------------- Private method start
// endregion
/**
* List转Array

5
hutool-core/src/test/java/cn/hutool/core/codec/hash/SimhashTest.java
View File

@ -1,6 +1,7 @@
package cn.hutool.core.codec.hash;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import org.junit.Assert;
import org.junit.Test;
@ -12,11 +13,11 @@ public class SimhashTest {
final String text2 = "我是 一个 普通 字符串";
final Simhash simhash = new Simhash();
final long hash = simhash.hash64(StrUtil.split(text1, ' '));
final long hash = simhash.hash64(SplitUtil.split(text1, StrUtil.SPACE));
Assert.assertTrue(hash != 0);
simhash.store(hash);
final boolean duplicate = simhash.equals(StrUtil.split(text2, ' '));
final boolean duplicate = simhash.equals(SplitUtil.split(text2, StrUtil.SPACE));
Assert.assertTrue(duplicate);
}
}

50
hutool-core/src/test/java/cn/hutool/core/text/SplitUtilTest.java
View File

@ -4,6 +4,8 @@ import cn.hutool.core.text.split.SplitUtil;
import org.junit.Assert;
import org.junit.Test;
import java.util.List;
public class SplitUtilTest {
@Test
@ -12,4 +14,52 @@ public class SplitUtilTest {
Assert.assertThrows(IllegalArgumentException.class, () -> SplitUtil.splitByLength("test length 0", 0));
}
@Test
public void splitToLongTest() {
final String str = "1,2,3,4, 5";
long[] longArray = SplitUtil.splitTo(str, ",", long[].class);
Assert.assertArrayEquals(new long[]{1, 2, 3, 4, 5}, longArray);
longArray = SplitUtil.splitTo(str, ",", long[].class);
Assert.assertArrayEquals(new long[]{1, 2, 3, 4, 5}, longArray);
}
@Test
public void splitToIntTest() {
final String str = "1,2,3,4, 5";
int[] intArray = SplitUtil.splitTo(str, ",", int[].class);
Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5}, intArray);
intArray = SplitUtil.splitTo(str, ",", int[].class);
Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5}, intArray);
}
@Test
public void splitTest() {
final String str = "a,b ,c,d,,e";
final List<String> split = SplitUtil.split(str, ",", -1, true, true);
// 测试空是否被去掉
Assert.assertEquals(5, split.size());
// 测试去掉两边空白符是否生效
Assert.assertEquals("b", split.get(1));
final String[] strings = SplitUtil.splitToArray("abc/", StrUtil.SLASH);
Assert.assertEquals(2, strings.length);
}
@Test
public void splitEmptyTest() {
final String str = "";
final List<String> split = SplitUtil.split(str, ",", -1, true, true);
// 测试空是否被去掉
Assert.assertEquals(0, split.size());
}
@Test
public void splitToArrayNullTest() {
final String[] strings = SplitUtil.splitToArray(null, ".");
Assert.assertNotNull(strings);
Assert.assertEquals(0, strings.length);
}
}

21
hutool-core/src/test/java/cn/hutool/core/text/StrRepeaterTest.java Normal file
View File

@ -0,0 +1,21 @@
package cn.hutool.core.text;
import org.junit.Assert;
import org.junit.Test;
public class StrRepeaterTest {
@Test
public void repeatByLengthTest() {
// 如果指定长度非指定字符串的整数倍，截断到固定长度
final String ab = StrRepeater.of(5).repeatByLength("ab");
Assert.assertEquals("ababa", ab);
}
@Test
public void repeatByLengthTest2() {
// 如果指定长度小于字符串本身的长度，截断之
final String ab = StrRepeater.of(2).repeatByLength("abcde");
Assert.assertEquals("ab", ab);
}
}

55
hutool-core/src/test/java/cn/hutool/core/text/StrUtilTest.java
View File

@ -1,6 +1,7 @@
package cn.hutool.core.text;
import cn.hutool.core.map.Dict;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.RandomUtil;
import org.junit.Assert;
@ -61,31 +62,10 @@ public class StrUtilTest {
Assert.assertArrayEquals(new String[]{"aaab", "bbcc", "cddd", "aadf", "dfsd", "fsdf", "0"}, cut);
}
@Test
public void splitTest() {
final String str = "a,b ,c,d,,e";
final List<String> split = StrUtil.split(str, ',', -1, true, true);
// 测试空是否被去掉
Assert.assertEquals(5, split.size());
// 测试去掉两边空白符是否生效
Assert.assertEquals("b", split.get(1));
final String[] strings = StrUtil.splitToArray("abc/", '/');
Assert.assertEquals(2, strings.length);
}
@Test
public void splitEmptyTest() {
final String str = "";
final List<String> split = StrUtil.split(str, ',', -1, true, true);
// 测试空是否被去掉
Assert.assertEquals(0, split.size());
}
@Test
public void splitTest2() {
final String str = "a.b.";
final List<String> split = StrUtil.split(str, '.');
final List<String> split = SplitUtil.split(str, ".");
Assert.assertEquals(3, split.size());
Assert.assertEquals("b", split.get(1));
Assert.assertEquals("", split.get(2));
@ -93,32 +73,7 @@ public class StrUtilTest {
@Test
public void splitNullTest() {
Assert.assertEquals(0, StrUtil.split(null, '.').size());
}
@Test(expected = IllegalArgumentException.class)
public void splitToArrayNullTest() {
StrUtil.splitToArray(null, '.');
}
@Test
public void splitToLongTest() {
final String str = "1,2,3,4, 5";
long[] longArray = StrUtil.splitToLong(str, ',');
Assert.assertArrayEquals(new long[]{1, 2, 3, 4, 5}, longArray);
longArray = StrUtil.splitToLong(str, ",");
Assert.assertArrayEquals(new long[]{1, 2, 3, 4, 5}, longArray);
}
@Test
public void splitToIntTest() {
final String str = "1,2,3,4, 5";
int[] intArray = StrUtil.splitToInt(str, ',');
Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5}, intArray);
intArray = StrUtil.splitToInt(str, ",");
Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5}, intArray);
Assert.assertEquals(0, SplitUtil.split(null, ".").size());
}
@Test
@ -576,10 +531,10 @@ public class StrUtilTest {
@Test
public void wrapAllTest() {
String[] strings = StrUtil.wrapAll("`", "`", StrUtil.splitToArray("1,2,3,4", ','));
String[] strings = StrUtil.wrapAll("`", "`", SplitUtil.splitToArray("1,2,3,4", ","));
Assert.assertEquals("[`1`, `2`, `3`, `4`]", StrUtil.utf8Str(strings));
strings = StrUtil.wrapAllWithPair("`", StrUtil.splitToArray("1,2,3,4", ','));
strings = StrUtil.wrapAllWithPair("`", SplitUtil.splitToArray("1,2,3,4", ","));
Assert.assertEquals("[`1`, `2`, `3`, `4`]", StrUtil.utf8Str(strings));
}

24
hutool-core/src/test/java/cn/hutool/core/text/split/StrSplitterTest.java
View File

@ -1,6 +1,5 @@
package cn.hutool.core.text.split;
import cn.hutool.core.lang.Console;
import org.junit.Assert;
import org.junit.Test;
@ -16,7 +15,7 @@ public class StrSplitterTest {
@Test
public void splitByCharTest(){
final String str1 = "a, ,efedsfs, ddf";
final List<String> split = SplitUtil.split(str1, ',', 0, true, true);
final List<String> split = SplitUtil.split(str1, ",", 0, true, true);
Assert.assertEquals("ddf", split.get(2));
Assert.assertEquals(3, split.size());
@ -33,15 +32,15 @@ public class StrSplitterTest {
@Test
public void splitByBlankTest(){
final String str1 = "aa bbccaa ddaaee";
final List<String> split = SplitUtil.split(str1, 0);
final List<String> split = SplitUtil.splitByBlank(str1);
Assert.assertEquals("ddaaee", split.get(2));
Assert.assertEquals(3, split.size());
}
@Test
public void splitPathTest(){
final String str1 = "/use/local/bin";
final List<String> split = SplitUtil.splitPath(str1, 0);
final String str1 = "/use/local\\bin";
final List<String> split = SplitUtil.splitPath(str1);
Assert.assertEquals("bin", split.get(2));
Assert.assertEquals(3, split.size());
}
@ -49,22 +48,25 @@ public class StrSplitterTest {
@Test
public void splitMappingTest() {
final String str = "1.2.";
final List<Long> split = SplitUtil.split(str, '.', 0, true, true, Long::parseLong);
final List<Long> split = SplitUtil.split(str, ".", 0, true, true, Long::parseLong);
Assert.assertEquals(2, split.size());
Assert.assertEquals(Long.valueOf(1L), split.get(0));
Assert.assertEquals(Long.valueOf(2L), split.get(1));
}
@SuppressWarnings("MismatchedReadAndWriteOfArray")
@Test
public void splitEmptyTest(){
final String str = "";
final String[] split = str.split(",");
final String[] strings = SplitUtil.splitToArray(str, ",", -1, false, false);
final String[] strings = SplitUtil.split(str, ",", -1, false, false)
.toArray(new String[0]);
Assert.assertNotNull(strings);
Assert.assertArrayEquals(split, strings);
final String[] strings2 = SplitUtil.splitToArray(str, ",", -1, false, true);
final String[] strings2 = SplitUtil.split(str, ",", -1, false, true)
.toArray(new String[0]);
Assert.assertEquals(0, strings2.length);
}
@ -72,11 +74,13 @@ public class StrSplitterTest {
@Test
public void splitNullTest(){
final String str = null;
final String[] strings = SplitUtil.splitToArray(str, ",", -1, false, false);
final String[] strings = SplitUtil.split(str, ",", -1, false, false)
.toArray(new String[0]);
Assert.assertNotNull(strings);
Assert.assertEquals(0, strings.length);
final String[] strings2 = SplitUtil.splitToArray(str, ",", -1, false, true);
final String[] strings2 = SplitUtil.split(str, ",", -1, false, true)
.toArray(new String[0]);
Assert.assertNotNull(strings2);
Assert.assertEquals(0, strings2.length);
}

14
hutool-cron/src/main/java/cn/hutool/cron/pattern/parser/PartParser.java
View File

@ -5,14 +5,10 @@ import cn.hutool.core.date.Month;
import cn.hutool.core.date.Week;
import cn.hutool.core.math.NumberUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.cron.CronException;
import cn.hutool.cron.pattern.Part;
import cn.hutool.cron.pattern.matcher.AlwaysTrueMatcher;
import cn.hutool.cron.pattern.matcher.BoolArrayMatcher;
import cn.hutool.cron.pattern.matcher.DayOfMonthMatcher;
import cn.hutool.cron.pattern.matcher.PartMatcher;
import cn.hutool.cron.pattern.matcher.YearValueMatcher;
import cn.hutool.cron.pattern.matcher.*;
import java.util.ArrayList;
import java.util.List;
@ -103,7 +99,7 @@ public class PartParser {
private List<Integer> parseArray(final String value) {
final List<Integer> values = new ArrayList<>();
final List<String> parts = StrUtil.split(value, CharUtil.COMMA);
final List<String> parts = SplitUtil.split(value, StrUtil.COMMA);
for (final String part : parts) {
ListUtil.addAllIfNotContains(values, parseStep(part));
}
@ -123,7 +119,7 @@ public class PartParser {
* @return List
*/
private List<Integer> parseStep(final String value) {
final List<String> parts = StrUtil.split(value, CharUtil.SLASH);
final List<String> parts = SplitUtil.split(value, StrUtil.SLASH);
final int size = parts.size();
final List<Integer> results;
@ -187,7 +183,7 @@ public class PartParser {
}
//Range模式
final List<String> parts = StrUtil.split(value, '-');
final List<String> parts = SplitUtil.split(value, StrUtil.DASHED);
final int size = parts.size();
if (size == 1) {// 普通值
final int v1 = parseNumber(value);

4
hutool-cron/src/main/java/cn/hutool/cron/pattern/parser/PatternParser.java
View File

@ -1,7 +1,7 @@
package cn.hutool.cron.pattern.parser;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.cron.CronException;
import cn.hutool.cron.pattern.Part;
import cn.hutool.cron.pattern.matcher.AlwaysTrueMatcher;
@ -47,7 +47,7 @@ public class PatternParser {
* @return {@link List}
*/
private static List<PatternMatcher> parseGroupPattern(final String groupPattern) {
final List<String> patternList = StrUtil.splitTrim(groupPattern, '|');
final List<String> patternList = SplitUtil.splitTrim(groupPattern, "|");
final List<PatternMatcher> patternMatchers = new ArrayList<>(patternList.size());
for (final String pattern : patternList) {
patternMatchers.add(parseSingle(pattern));

17
hutool-db/src/main/java/cn/hutool/db/sql/Condition.java
View File

@ -426,11 +426,11 @@ public class Condition implements Cloneable, Serializable {
// pr#2046@Github
valuesForIn = (Collection<?>) value;
} else if (value instanceof CharSequence) {
valuesForIn = StrUtil.split((CharSequence) value, ',');
valuesForIn = SplitUtil.split((CharSequence) value, StrUtil.COMMA);
} else {
valuesForIn = Arrays.asList(Convert.convert(Object[].class, value));
}
conditionStrBuilder.append(StrUtil.repeatAndJoin("?", valuesForIn.size(), ","));
conditionStrBuilder.append(StrUtil.repeatAndJoin("?", valuesForIn.size(), StrUtil.COMMA));
if (null != paramValues) {
paramValues.addAll(valuesForIn);
}
@ -490,13 +490,13 @@ public class Condition implements Cloneable, Serializable {
}
}
final List<String> strs = StrUtil.split(valueStr, CharUtil.SPACE, 2);
final List<String> strs = SplitUtil.split(valueStr, StrUtil.SPACE, 2, true, false);
if (strs.size() < 2) {
return;
}
// 处理常用符号和IN
final String firstPart = strs.get(0).trim().toUpperCase();
final String firstPart = strs.get(0).toUpperCase();
if (OPERATORS.contains(firstPart)) {
this.operator = firstPart;
// 比较符号后跟大部分为数字，此处做转换（IN不做转换）
@ -514,7 +514,8 @@ public class Condition implements Cloneable, Serializable {
// 处理BETWEEN x AND y
if (OPERATOR_BETWEEN.equals(firstPart)) {
final List<String> betweenValueStrs = SplitUtil.splitTrimIgnoreCase(strs.get(1), LogicalOperator.AND.toString(), 2, true);
final List<String> betweenValueStrs = SplitUtil.split(strs.get(1), LogicalOperator.AND.toString(),
2, true, true, true);
if (betweenValueStrs.size() < 2) {
// 必须满足a AND b格式，不满足被当作普通值
return;
@ -532,11 +533,10 @@ public class Condition implements Cloneable, Serializable {
* @param value 值
* @return 去掉引号后的值
*/
private static String unwrapQuote(String value) {
private static String unwrapQuote(final String value) {
if (null == value) {
return null;
}
value = value.trim();
int from = 0;
int to = value.length();
@ -562,8 +562,7 @@ public class Condition implements Cloneable, Serializable {
* @param value 被转换的字符串值
* @return 转换后的值
*/
private static Object tryToNumber(String value) {
value = StrUtil.trim(value);
private static Object tryToNumber(final String value) {
if (false == NumberUtil.isNumber(value)) {
return value;
}

8
hutool-db/src/main/java/cn/hutool/db/sql/QuoteWrapper.java
View File

@ -2,8 +2,8 @@ package cn.hutool.db.sql;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.db.Entity;
import java.io.Serializable;
@ -115,7 +115,11 @@ public class QuoteWrapper implements Serializable {
//对于Oracle这类数据库，表名中包含用户名需要单独拆分包装
if (field.contains(StrUtil.DOT)) {
final Collection<String> target = CollUtil.edit(StrUtil.split(field, CharUtil.DOT, 2), t -> StrUtil.format("{}{}{}", preWrapQuote, t, sufWrapQuote));
final Collection<String> target = CollUtil.edit(
// 用户名和表名不能包含空格
SplitUtil.split(field, StrUtil.DOT, 2, true, false),
// 用户名和表名都加引号
t -> StrUtil.format("{}{}{}", preWrapQuote, t, sufWrapQuote));
return CollUtil.join(target, StrUtil.DOT);
}

3
hutool-db/src/test/java/cn/hutool/db/meta/MetaUtilTest.java
View File

@ -2,6 +2,7 @@ package cn.hutool.db.meta;
import cn.hutool.core.collection.SetUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.db.ds.DSFactory;
import org.junit.Assert;
import org.junit.Test;
@ -33,7 +34,7 @@ public class MetaUtilTest {
@Test
public void getColumnNamesTest() {
final String[] names = MetaUtil.getColumnNames(ds, "user");
Assert.assertArrayEquals(StrUtil.splitToArray("id,name,age,birthday,gender", ','), names);
Assert.assertArrayEquals(SplitUtil.splitToArray("id,name,age,birthday,gender", StrUtil.COMMA), names);
}
@Test

5
hutool-extra/src/main/java/cn/hutool/extra/mail/MailUtil.java
View File

@ -4,6 +4,7 @@ import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.text.StrUtil;
@ -430,9 +431,9 @@ public class MailUtil {
final List<String> result;
if (StrUtil.contains(addresses, CharUtil.COMMA)) {
result = StrUtil.splitTrim(addresses, CharUtil.COMMA);
result = SplitUtil.splitTrim(addresses, StrUtil.COMMA);
} else if (StrUtil.contains(addresses, ';')) {
result = StrUtil.splitTrim(addresses, ';');
result = SplitUtil.splitTrim(addresses, ";");
} else {
result = ListUtil.of(addresses);
}

26
hutool-extra/src/main/java/cn/hutool/extra/management/JavaRuntimeInfo.java
View File

@ -1,6 +1,6 @@
package cn.hutool.extra.management;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.SystemUtil;
import java.io.Serializable;
@ -8,7 +8,7 @@ import java.io.Serializable;
/**
* 代表当前运行的JRE的信息。
*/
public class JavaRuntimeInfo implements Serializable{
public class JavaRuntimeInfo implements Serializable {
private static final long serialVersionUID = 1L;
private final String JAVA_RUNTIME_NAME = SystemUtil.get("java.runtime.name", false);
@ -24,6 +24,11 @@ public class JavaRuntimeInfo implements Serializable{
private final String SUN_ARCH_DATA_MODEL = SystemUtil.get("sun.arch.data.model", false);
/**
* 获取JRE的classpath
*
* @return JRE的classpath
*/
public final String getSunBoothClassPath() {
return SUN_BOOT_CLASS_PATH;
}
@ -45,7 +50,6 @@ public class JavaRuntimeInfo implements Serializable{
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.3
*/
public final String getName() {
@ -60,7 +64,6 @@ public class JavaRuntimeInfo implements Serializable{
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.3
*/
public final String getVersion() {
@ -75,7 +78,6 @@ public class JavaRuntimeInfo implements Serializable{
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String getHomeDir() {
@ -90,7 +92,6 @@ public class JavaRuntimeInfo implements Serializable{
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.3
*/
public final String getExtDirs() {
@ -105,7 +106,6 @@ public class JavaRuntimeInfo implements Serializable{
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.4
*/
public final String getEndorsedDirs() {
@ -120,7 +120,6 @@ public class JavaRuntimeInfo implements Serializable{
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String getClassPath() {
@ -135,11 +134,10 @@ public class JavaRuntimeInfo implements Serializable{
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String[] getClassPathArray() {
return StrUtil.splitToArray(getClassPath(), SystemUtil.get("path.separator", false));
return SplitUtil.splitToArray(getClassPath(), SystemUtil.get("path.separator", false));
}
/**
@ -150,7 +148,6 @@ public class JavaRuntimeInfo implements Serializable{
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
* @since Java 1.1
*/
public final String getClassVersion() {
@ -165,7 +162,6 @@ public class JavaRuntimeInfo implements Serializable{
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*/
public final String getLibraryPath() {
return JAVA_LIBRARY_PATH;
@ -179,11 +175,9 @@ public class JavaRuntimeInfo implements Serializable{
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*
*/
public final String[] getLibraryPathArray() {
return StrUtil.splitToArray(getLibraryPath(), SystemUtil.get("path.separator", false));
return SplitUtil.splitToArray(getLibraryPath(), SystemUtil.get("path.separator", false));
}
/**
@ -194,8 +188,6 @@ public class JavaRuntimeInfo implements Serializable{
* </p>
*
* @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
*
*
*/
public final String getProtocolPackages() {
return SystemUtil.get("java.protocol.handler.pkgs", true);

3
hutool-extra/src/main/java/cn/hutool/extra/pinyin/PinyinEngine.java
View File

@ -2,6 +2,7 @@ package cn.hutool.extra.pinyin;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import java.util.List;
@ -49,7 +50,7 @@ public interface PinyinEngine {
*/
default String getFirstLetter(final String str, final String separator) {
final String splitSeparator = StrUtil.isEmpty(separator) ? "#" : separator;
final List<String> split = StrUtil.split(getPinyin(str, splitSeparator), splitSeparator);
final List<String> split = SplitUtil.split(getPinyin(str, splitSeparator), splitSeparator);
return CollUtil.join(split, separator, (s)->String.valueOf(s.length() > 0 ? s.charAt(0) : StrUtil.EMPTY));
}
}

3
hutool-http/src/main/java/cn/hutool/http/webservice/SoapClient.java
View File

@ -4,6 +4,7 @@ import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.XmlUtil;
@ -398,7 +399,7 @@ public class SoapClient implements HeaderOperation<SoapClient> {
* @return this
*/
public SoapClient setMethod(final String methodName, final String namespaceURI) {
final List<String> methodNameList = StrUtil.split(methodName, ':');
final List<String> methodNameList = SplitUtil.split(methodName, StrUtil.COLON);
final QName qName;
if (2 == methodNameList.size()) {
qName = new QName(namespaceURI, methodNameList.get(1), methodNameList.get(0));

3
hutool-json/src/main/java/cn/hutool/json/InternalJSONUtil.java
View File

@ -12,6 +12,7 @@ import cn.hutool.core.reflect.ClassUtil;
import cn.hutool.core.reflect.ConstructorUtil;
import cn.hutool.core.reflect.TypeUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.ObjUtil;
@ -210,7 +211,7 @@ public final class InternalJSONUtil {
* @param predicate 属性过滤器，{@link Predicate#test(Object)}为{@code true}保留
*/
public static void propertyPut(final JSONObject jsonObject, final Object key, final Object value, final Predicate<MutableEntry<String, Object>> predicate) {
final String[] path = StrUtil.splitToArray(Convert.toStr(key), CharUtil.DOT);
final String[] path = SplitUtil.splitToArray(Convert.toStr(key), StrUtil.DOT);
final int last = path.length - 1;
JSONObject target = jsonObject;
for (int i = 0; i < last; i += 1) {

4
hutool-json/src/main/java/cn/hutool/json/jwt/JWT.java
View File

@ -6,7 +6,7 @@ import cn.hutool.core.date.DateUtil;
import cn.hutool.core.exceptions.ValidateException;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.jwt.signers.AlgorithmUtil;
@ -423,7 +423,7 @@ public class JWT implements RegisteredPayload<JWT> {
* @return 三部分内容
*/
private static List<String> splitToken(final String token) {
final List<String> tokens = StrUtil.split(token, CharUtil.DOT);
final List<String> tokens = SplitUtil.split(token, StrUtil.DOT);
if (3 != tokens.size()) {
throw new JWTException("The token was expected 3 parts, but got {}.", tokens.size());
}

3
hutool-setting/src/main/java/cn/hutool/setting/AbsSetting.java
View File

@ -10,6 +10,7 @@ import cn.hutool.core.lang.getter.GroupedTypeGetter;
import cn.hutool.core.lang.getter.TypeGetter;
import cn.hutool.core.reflect.ConstructorUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.ObjUtil;
import java.io.Serializable;
@ -125,7 +126,7 @@ public abstract class AbsSetting implements TypeGetter<CharSequence>,
if (StrUtil.isBlank(value)) {
return null;
}
return StrUtil.splitToArray(value, delimiter);
return SplitUtil.splitToArray(value, delimiter);
}
/**

8
hutool-setting/src/main/java/cn/hutool/setting/SettingLoader.java
View File

@ -7,6 +7,7 @@ import cn.hutool.core.io.resource.Resource;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.regex.ReUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.SystemUtil;
@ -124,13 +125,14 @@ public class SettingLoader {
continue;
}
final String[] keyValue = StrUtil.splitToArray(line, this.assignFlag, 2);
final String[] keyValue = SplitUtil.split(line, String.valueOf(this.assignFlag), 2, true, false)
.toArray(new String[0]);
// 跳过不符合键值规范的行
if (keyValue.length < 2) {
continue;
}
String value = keyValue[1].trim();
String value = keyValue[1];
// 替换值中的所有变量变量（变量必须是此行之前定义的变量，否则无法找到）
if (this.isUseVariable) {
value = replaceVar(group, value);
@ -224,7 +226,7 @@ public class SettingLoader {
String varValue = this.groupedMap.get(group, key);
// 跨分组查找
if (null == varValue) {
final List<String> groupAndKey = StrUtil.split(key, CharUtil.DOT, 2);
final List<String> groupAndKey = SplitUtil.split(key, StrUtil.DOT, 2, true, false);
if (groupAndKey.size() > 1) {
varValue = this.groupedMap.get(groupAndKey.get(0), groupAndKey.get(1));
}

25
hutool-swing/src/main/java/cn/hutool/swing/img/color/ColorUtil.java
View File

@ -6,6 +6,8 @@ import cn.hutool.core.lang.ansi.Ansi8BitColor;
import cn.hutool.core.lang.ansi.AnsiElement;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.text.StrUtil;
import cn.hutool.core.text.split.SplitUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.RandomUtil;
import java.awt.Color;
@ -23,6 +25,7 @@ import java.util.Random;
public class ColorUtil {
private static final Map<String, Color> COLOR_MAPPING;
static {
final Map<String, Color> colorMap = MapUtil
.builder("BLACK", Color.BLACK)
@ -57,10 +60,11 @@ public class ColorUtil {
/**
* 将颜色转换为CSS的rgba表示形式，输出结果格式为：rgba(red, green, blue)
*
* @param color AWT颜色
* @return rgb(red, green, blue)
*/
public static String toCssRgb(final Color color){
public static String toCssRgb(final Color color) {
return StrUtil.builder()
.append("rgb(")
.append(color.getRed()).append(",")
@ -71,10 +75,11 @@ public class ColorUtil {
/**
* 将颜色转换为CSS的rgba表示形式，输出结果格式为：rgba(red, green, blue, alpha)
*
* @param color AWT颜色
* @return rgba(red, green, blue, alpha)
*/
public static String toCssRgba(final Color color){
public static String toCssRgba(final Color color) {
return StrUtil.builder()
.append("rgba(")
.append(color.getRed()).append(",")
@ -135,7 +140,7 @@ public class ColorUtil {
// 预定义颜色别名
final Color color = COLOR_MAPPING.get(colorName);
if(null != color){
if (null != color) {
return color;
}
@ -148,19 +153,19 @@ public class ColorUtil {
}
// RGB值和RGBA
final List<String> rgb = StrUtil.split(colorName, ',');
final List<String> rgb = SplitUtil.split(colorName, StrUtil.COMMA);
final int size = rgb.size();
if(3 == size){
if (3 == size) {
// RGB
final Integer[] rgbIntegers = Convert.toIntArray(rgb);
return new Color(rgbIntegers[0], rgbIntegers[1], rgbIntegers[2]);
}
if(4 == size){
if (4 == size) {
// RGBA
final Float[] rgbFloats = Convert.toFloatArray(rgb);
Float a = rgbFloats[3];
if(a < 1){
if (a < 1) {
// 识别CSS形式
a *= 255;
}
@ -243,7 +248,7 @@ public class ColorUtil {
/**
* AWT的{@link Color}颜色转换为ANSI颜色，由于取最接近颜色，故可能有色差
*
* @param rgb RGB颜色
* @param rgb RGB颜色
* @param is8Bit 是否8bit的ANSI颜色
* @param isBackground 是否背景色
* @return ANSI颜色
@ -313,7 +318,7 @@ public class ColorUtil {
maxCount = count;
}
}
final String[] splitRgbStr = StrUtil.splitToArray(maxColor, '-');
final String[] splitRgbStr = SplitUtil.splitToArray(maxColor, StrUtil.DASHED);
String rHex = Integer.toHexString(Integer.parseInt(splitRgbStr[0]));
String gHex = Integer.toHexString(Integer.parseInt(splitRgbStr[1]));
String bHex = Integer.toHexString(Integer.parseInt(splitRgbStr[2]));
@ -333,7 +338,7 @@ public class ColorUtil {
* @return 是否匹配
*/
private static boolean matchFilters(final int r, final int g, final int b, final int[]... rgbFilters) {
if (rgbFilters != null && rgbFilters.length > 0) {
if (ArrayUtil.isNotEmpty(rgbFilters)) {
for (final int[] rgbFilter : rgbFilters) {
if (r == rgbFilter[0] && g == rgbFilter[1] && b == rgbFilter[2]) {
return true;