diff --git a/CHANGELOG.md b/CHANGELOG.md
index 65d30e6ba..2f1a63c30 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,15 +3,17 @@
-------------------------------------------------------------------------------------------------------------
-# 5.5.9 (2021-02-03)
+# 5.5.9 (2021-02-18)
### 新特性
* 【crypto 】 PemUtil.readPemKey支持EC（pr#1366@Github）
* 【extra 】 Ftp等cd方法增加同步（issue#1397@Github）
+* 【core 】 StrUtil增加endWithAnyIgnoreCase（issue#I37I0B@Gitee）
### Bug修复
* 【json 】 JSONUtil.isJson方法改变trim策略，解决特殊空白符导致判断失败问题
* 【json 】 修复SQLEXception导致的栈溢出（issue#1399@Github）
+* 【extra 】 修复Ftp中异常参数没有传入问题（issue#1397@Github）
-------------------------------------------------------------------------------------------------------------
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java b/hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java
index 552d40397..a594d9e81 100644
--- a/hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java
@@ -839,6 +839,28 @@ public class CharSequenceUtil {
return false;
}
+ /**
+ * 给定字符串是否以任何一个字符串结尾（忽略大小写）
+ * 给定字符串和数组为空都返回false
+ *
+ * @param str 给定字符串
+ * @param suffixes 需要检测的结尾字符串
+ * @return 给定字符串是否以任何一个字符串结尾
+ * @since 5.5.9
+ */
+ public static boolean endWithAnyIgnoreCase(CharSequence str, CharSequence... suffixes) {
+ if (isEmpty(str) || ArrayUtil.isEmpty(suffixes)) {
+ return false;
+ }
+
+ for (CharSequence suffix : suffixes) {
+ if (endWith(str, suffix, true)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
// ------------------------------------------------------------------------ contains
/**
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/StrSpliter.java b/hutool-core/src/main/java/cn/hutool/core/text/StrSpliter.java
index b85eb60bf..2be5e8546 100644
--- a/hutool-core/src/main/java/cn/hutool/core/text/StrSpliter.java
+++ b/hutool-core/src/main/java/cn/hutool/core/text/StrSpliter.java
@@ -12,453 +12,457 @@ import java.util.regex.Pattern;
/**
* 字符串切分器
- * @author Looly
*
+ * @author Looly
*/
public class StrSpliter {
-
+
//---------------------------------------------------------------------------------------------- Split by char
+
/**
* 切分字符串路径，仅支持Unix分界符：/
- *
+ *
* @param str 被切分的字符串
* @return 切分后的集合
* @since 3.0.8
*/
- public static List splitPath(String str){
+ public static List splitPath(String str) {
return splitPath(str, 0);
}
-
+
/**
* 切分字符串路径，仅支持Unix分界符：/
- *
+ *
* @param str 被切分的字符串
* @return 切分后的集合
* @since 3.0.8
*/
- public static String[] splitPathToArray(String str){
+ public static String[] splitPathToArray(String str) {
return toArray(splitPath(str));
}
-
+
/**
* 切分字符串路径，仅支持Unix分界符：/
- *
- * @param str 被切分的字符串
+ *
+ * @param str 被切分的字符串
* @param limit 限制分片数
* @return 切分后的集合
* @since 3.0.8
*/
- public static List splitPath(String str, int limit){
+ public static List splitPath(String str, int limit) {
return split(str, StrUtil.C_SLASH, limit, true, true);
}
-
+
/**
* 切分字符串路径，仅支持Unix分界符：/
- *
- * @param str 被切分的字符串
+ *
+ * @param str 被切分的字符串
* @param limit 限制分片数
* @return 切分后的集合
* @since 3.0.8
*/
- public static String[] splitPathToArray(String str, int limit){
+ public static String[] splitPathToArray(String str, int limit) {
return toArray(splitPath(str, limit));
}
-
+
/**
* 切分字符串
- *
- * @param str 被切分的字符串
- * @param separator 分隔符字符
+ *
+ * @param str 被切分的字符串
+ * @param separator 分隔符字符
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
- public static List splitTrim(String str, char separator, boolean ignoreEmpty){
+ public static List splitTrim(String str, char separator, boolean ignoreEmpty) {
return split(str, separator, 0, true, ignoreEmpty);
}
-
+
/**
* 切分字符串
- *
- * @param str 被切分的字符串
- * @param separator 分隔符字符
- * @param isTrim 是否去除切分字符串后每个元素两边的空格
+ *
+ * @param str 被切分的字符串
+ * @param separator 分隔符字符
+ * @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
- public static List split(String str, char separator, boolean isTrim, boolean ignoreEmpty){
+ public static List split(String str, char separator, boolean isTrim, boolean ignoreEmpty) {
return split(str, separator, 0, isTrim, ignoreEmpty);
}
-
+
/**
* 切分字符串，大小写敏感，去除每个元素两边空白符
- *
- * @param str 被切分的字符串
- * @param separator 分隔符字符
- * @param limit 限制分片数，-1不限制
+ *
+ * @param str 被切分的字符串
+ * @param separator 分隔符字符
+ * @param limit 限制分片数，-1不限制
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
- public static List splitTrim(String str, char separator, int limit, boolean ignoreEmpty){
+ public static List splitTrim(String str, char separator, int limit, boolean ignoreEmpty) {
return split(str, separator, limit, true, ignoreEmpty, false);
}
-
+
/**
* 切分字符串，大小写敏感
- *
- * @param str 被切分的字符串
- * @param separator 分隔符字符
- * @param limit 限制分片数，-1不限制
- * @param isTrim 是否去除切分字符串后每个元素两边的空格
+ *
+ * @param str 被切分的字符串
+ * @param separator 分隔符字符
+ * @param limit 限制分片数，-1不限制
+ * @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
- public static List split(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty){
+ public static List split(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty) {
return split(str, separator, limit, isTrim, ignoreEmpty, false);
}
-
+
/**
* 切分字符串，忽略大小写
- *
- * @param str 被切分的字符串
- * @param separator 分隔符字符
- * @param limit 限制分片数，-1不限制
- * @param isTrim 是否去除切分字符串后每个元素两边的空格
+ *
+ * @param str 被切分的字符串
+ * @param separator 分隔符字符
+ * @param limit 限制分片数，-1不限制
+ * @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
- public static List splitIgnoreCase(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty){
+ public static List splitIgnoreCase(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty) {
return split(str, separator, limit, isTrim, ignoreEmpty, true);
}
-
+
/**
* 切分字符串
- *
- * @param str 被切分的字符串
- * @param separator 分隔符字符
- * @param limit 限制分片数，-1不限制
- * @param isTrim 是否去除切分字符串后每个元素两边的空格
+ *
+ * @param str 被切分的字符串
+ * @param separator 分隔符字符
+ * @param limit 限制分片数，-1不限制
+ * @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
- * @param ignoreCase 是否忽略大小写
+ * @param ignoreCase 是否忽略大小写
* @return 切分后的集合
* @since 3.2.1
*/
- public static List split(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty, boolean ignoreCase){
- if(StrUtil.isEmpty(str)){
+ public static List split(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty, boolean ignoreCase) {
+ if (StrUtil.isEmpty(str)) {
return new ArrayList<>(0);
}
- if(limit == 1){
+ if (limit == 1) {
return addToList(new ArrayList<>(1), str, isTrim, ignoreEmpty);
}
-
+
final ArrayList list = new ArrayList<>(limit > 0 ? limit : 16);
int len = str.length();
int start = 0;//切分后每个部分的起始
- for(int i = 0; i < len; i++){
- if(NumberUtil.equals(separator, str.charAt(i), ignoreCase)){
+ for (int i = 0; i < len; i++) {
+ if (NumberUtil.equals(separator, str.charAt(i), ignoreCase)) {
addToList(list, str.substring(start, i), isTrim, ignoreEmpty);
- start = i+1;//i+1同时将start与i保持一致
-
+ start = i + 1;//i+1同时将start与i保持一致
+
//检查是否超出范围（最大允许limit-1个，剩下一个留给末尾字符串）
- if(limit > 0 && list.size() > limit-2){
+ if (limit > 0 && list.size() > limit - 2) {
break;
}
}
}
return addToList(list, str.substring(start, len), isTrim, ignoreEmpty);//收尾
}
-
+
/**
* 切分字符串为字符串数组
- *
- * @param str 被切分的字符串
- * @param separator 分隔符字符
- * @param limit 限制分片数
- * @param isTrim 是否去除切分字符串后每个元素两边的空格
+ *
+ * @param str 被切分的字符串
+ * @param separator 分隔符字符
+ * @param limit 限制分片数
+ * @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
- public static String[] splitToArray(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty){
+ public static String[] splitToArray(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty) {
return toArray(split(str, separator, limit, isTrim, ignoreEmpty));
}
-
+
//---------------------------------------------------------------------------------------------- Split by String
-
+
/**
* 切分字符串，不忽略大小写
- *
- * @param str 被切分的字符串
- * @param separator 分隔符字符串
- * @param isTrim 是否去除切分字符串后每个元素两边的空格
+ *
+ * @param str 被切分的字符串
+ * @param separator 分隔符字符串
+ * @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
- public static List split(String str, String separator, boolean isTrim, boolean ignoreEmpty){
+ public static List split(String str, String separator, boolean isTrim, boolean ignoreEmpty) {
return split(str, separator, -1, isTrim, ignoreEmpty, false);
}
-
+
/**
* 切分字符串，去除每个元素两边空格，忽略大小写
- *
- * @param str 被切分的字符串
- * @param separator 分隔符字符串
+ *
+ * @param str 被切分的字符串
+ * @param separator 分隔符字符串
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
- public static List splitTrim(String str, String separator, boolean ignoreEmpty){
+ public static List splitTrim(String str, String separator, boolean ignoreEmpty) {
return split(str, separator, true, ignoreEmpty);
}
-
+
/**
* 切分字符串，不忽略大小写
- *
- * @param str 被切分的字符串
- * @param separator 分隔符字符串
- * @param limit 限制分片数
- * @param isTrim 是否去除切分字符串后每个元素两边的空格
+ *
+ * @param str 被切分的字符串
+ * @param separator 分隔符字符串
+ * @param limit 限制分片数
+ * @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
- public static List split(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty){
+ public static List split(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty) {
return split(str, separator, limit, isTrim, ignoreEmpty, false);
}
-
+
/**
* 切分字符串，去除每个元素两边空格，忽略大小写
- *
- * @param str 被切分的字符串
- * @param separator 分隔符字符串
- * @param limit 限制分片数
+ *
+ * @param str 被切分的字符串
+ * @param separator 分隔符字符串
+ * @param limit 限制分片数
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
- public static List splitTrim(String str, String separator, int limit, boolean ignoreEmpty){
+ public static List splitTrim(String str, String separator, int limit, boolean ignoreEmpty) {
return split(str, separator, limit, true, ignoreEmpty);
}
-
+
/**
* 切分字符串，忽略大小写
- *
- * @param str 被切分的字符串
- * @param separator 分隔符字符串
- * @param limit 限制分片数
- * @param isTrim 是否去除切分字符串后每个元素两边的空格
+ *
+ * @param str 被切分的字符串
+ * @param separator 分隔符字符串
+ * @param limit 限制分片数
+ * @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
- public static List splitIgnoreCase(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty){
+ public static List splitIgnoreCase(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty) {
return split(str, separator, limit, isTrim, ignoreEmpty, true);
}
-
+
/**
* 切分字符串，去除每个元素两边空格，忽略大小写
- *
- * @param str 被切分的字符串
- * @param separator 分隔符字符串
- * @param limit 限制分片数
+ *
+ * @param str 被切分的字符串
+ * @param separator 分隔符字符串
+ * @param limit 限制分片数
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
- public static List splitTrimIgnoreCase(String str, String separator, int limit, boolean ignoreEmpty){
+ public static List splitTrimIgnoreCase(String str, String separator, int limit, boolean ignoreEmpty) {
return split(str, separator, limit, true, ignoreEmpty, true);
}
-
+
/**
* 切分字符串
- *
- * @param str 被切分的字符串
- * @param separator 分隔符字符串
- * @param limit 限制分片数
- * @param isTrim 是否去除切分字符串后每个元素两边的空格
+ *
+ * @param str 被切分的字符串
+ * @param separator 分隔符字符串
+ * @param limit 限制分片数
+ * @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
- * @param ignoreCase 是否忽略大小写
+ * @param ignoreCase 是否忽略大小写
* @return 切分后的集合
* @since 3.2.1
*/
- public static List split(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty, boolean ignoreCase){
- if(StrUtil.isEmpty(str)){
+ public static List split(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty, boolean ignoreCase) {
+ if (StrUtil.isEmpty(str)) {
return new ArrayList<>(0);
}
- if(limit == 1){
+ if (limit == 1) {
return addToList(new ArrayList<>(1), str, isTrim, ignoreEmpty);
}
-
- if(StrUtil.isEmpty(separator)){//分隔符为空时按照空白符切分
+
+ if (StrUtil.isEmpty(separator)) {//分隔符为空时按照空白符切分
return split(str, limit);
- }else if(separator.length() == 1){//分隔符只有一个字符长度时按照单分隔符切分
+ } else if (separator.length() == 1) {//分隔符只有一个字符长度时按照单分隔符切分
return split(str, separator.charAt(0), limit, isTrim, ignoreEmpty, ignoreCase);
}
-
+
final ArrayList list = new ArrayList<>();
int len = str.length();
int separatorLen = separator.length();
int start = 0;
int i = 0;
- while(i < len){
+ while (i < len) {
i = StrUtil.indexOf(str, separator, start, ignoreCase);
- if(i > -1){
+ if (i > -1) {
addToList(list, str.substring(start, i), isTrim, ignoreEmpty);
start = i + separatorLen;
-
+
//检查是否超出范围（最大允许limit-1个，剩下一个留给末尾字符串）
- if(limit > 0 && list.size() > limit-2){
+ if (limit > 0 && list.size() > limit - 2) {
break;
}
- }else{
+ } else {
break;
}
}
return addToList(list, str.substring(start, len), isTrim, ignoreEmpty);
}
-
+
/**
* 切分字符串为字符串数组
- *
- * @param str 被切分的字符串
- * @param separator 分隔符字符
- * @param limit 限制分片数
- * @param isTrim 是否去除切分字符串后每个元素两边的空格
+ *
+ * @param str 被切分的字符串
+ * @param separator 分隔符字符
+ * @param limit 限制分片数
+ * @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
- public static String[] splitToArray(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty){
+ public static String[] splitToArray(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty) {
return toArray(split(str, separator, limit, isTrim, ignoreEmpty));
}
-
+
//---------------------------------------------------------------------------------------------- Split by Whitespace
-
+
/**
* 使用空白符切分字符串
* 切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一
- *
- * @param str 被切分的字符串
+ *
+ * @param str 被切分的字符串
* @param limit 限制分片数
* @return 切分后的集合
* @since 3.0.8
*/
- public static List split(String str, int limit){
- if(StrUtil.isEmpty(str)){
+ public static List split(String str, int limit) {
+ if (StrUtil.isEmpty(str)) {
return new ArrayList<>(0);
}
- if(limit == 1){
+ if (limit == 1) {
return addToList(new ArrayList<>(1), str, true, true);
}
-
+
final ArrayList list = new ArrayList<>();
int len = str.length();
int start = 0;//切分后每个部分的起始
- for(int i = 0; i < len; i++){
- if(CharUtil.isBlankChar(str.charAt(i))){
+ for (int i = 0; i < len; i++) {
+ if (CharUtil.isBlankChar(str.charAt(i))) {
addToList(list, str.substring(start, i), true, true);
- start = i+1;//i+1同时将start与i保持一致
-
+ start = i + 1;//i+1同时将start与i保持一致
+
//检查是否超出范围（最大允许limit-1个，剩下一个留给末尾字符串）
- if(limit > 0 && list.size() > limit-2){
+ if (limit > 0 && list.size() > limit - 2) {
break;
}
}
}
return addToList(list, str.substring(start, len), true, true);//收尾
}
-
+
/**
* 切分字符串为字符串数组
- *
- * @param str 被切分的字符串
+ *
+ * @param str 被切分的字符串
* @param limit 限制分片数
* @return 切分后的集合
* @since 3.0.8
*/
- public static String[] splitToArray(String str, int limit){
+ public static String[] splitToArray(String str, int limit) {
return toArray(split(str, limit));
}
-
+
//---------------------------------------------------------------------------------------------- Split by regex
+
/**
* 通过正则切分字符串
- * @param str 字符串
+ *
+ * @param str 字符串
* @param separatorRegex 分隔符正则
- * @param limit 限制分片数
- * @param isTrim 是否去除切分字符串后每个元素两边的空格
- * @param ignoreEmpty 是否忽略空串
+ * @param limit 限制分片数
+ * @param isTrim 是否去除切分字符串后每个元素两边的空格
+ * @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
- public static List splitByRegex(String str, String separatorRegex, int limit, boolean isTrim, boolean ignoreEmpty){
+ public static List splitByRegex(String str, String separatorRegex, int limit, boolean isTrim, boolean ignoreEmpty) {
final Pattern pattern = PatternPool.get(separatorRegex);
return split(str, pattern, limit, isTrim, ignoreEmpty);
}
-
+
/**
* 通过正则切分字符串
- * @param str 字符串
+ *
+ * @param str 字符串
* @param separatorPattern 分隔符正则{@link Pattern}
- * @param limit 限制分片数
- * @param isTrim 是否去除切分字符串后每个元素两边的空格
- * @param ignoreEmpty 是否忽略空串
+ * @param limit 限制分片数
+ * @param isTrim 是否去除切分字符串后每个元素两边的空格
+ * @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
- public static List split(String str, Pattern separatorPattern, int limit, boolean isTrim, boolean ignoreEmpty){
- if(StrUtil.isEmpty(str)){
+ public static List split(String str, Pattern separatorPattern, int limit, boolean isTrim, boolean ignoreEmpty) {
+ if (StrUtil.isEmpty(str)) {
return new ArrayList<>(0);
}
- if(limit == 1){
+ if (limit == 1) {
return addToList(new ArrayList<>(1), str, isTrim, ignoreEmpty);
}
-
- if(null == separatorPattern){//分隔符为空时按照空白符切分
+
+ if (null == separatorPattern) {//分隔符为空时按照空白符切分
return split(str, limit);
}
-
+
final Matcher matcher = separatorPattern.matcher(str);
final ArrayList list = new ArrayList<>();
int len = str.length();
int start = 0;
- while(matcher.find()){
+ while (matcher.find()) {
addToList(list, str.substring(start, matcher.start()), isTrim, ignoreEmpty);
start = matcher.end();
-
+
//检查是否超出范围（最大允许limit-1个，剩下一个留给末尾字符串）
- if(limit > 0 && list.size() > limit-2){
+ if (limit > 0 && list.size() > limit - 2) {
break;
}
}
return addToList(list, str.substring(start, len), isTrim, ignoreEmpty);
}
-
+
/**
* 通过正则切分字符串为字符串数组
- *
- * @param str 被切分的字符串
+ *
+ * @param str 被切分的字符串
* @param separatorPattern 分隔符正则{@link Pattern}
- * @param limit 限制分片数
- * @param isTrim 是否去除切分字符串后每个元素两边的空格
- * @param ignoreEmpty 是否忽略空串
+ * @param limit 限制分片数
+ * @param isTrim 是否去除切分字符串后每个元素两边的空格
+ * @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
- public static String[] splitToArray(String str, Pattern separatorPattern, int limit, boolean isTrim, boolean ignoreEmpty){
+ public static String[] splitToArray(String str, Pattern separatorPattern, int limit, boolean isTrim, boolean ignoreEmpty) {
return toArray(split(str, separatorPattern, limit, isTrim, ignoreEmpty));
}
-
+
//---------------------------------------------------------------------------------------------- Split by length
-
+
/**
* 根据给定长度，将给定字符串截取为多个部分
- *
+ *
* @param str 字符串
* @param len 每一个小节的长度
* @return 截取后的字符串数组
@@ -481,32 +485,35 @@ public class StrSpliter {
}
return strs;
}
-
+
//---------------------------------------------------------------------------------------------------------- Private method start
+
/**
* 将字符串加入List中
- * @param list 列表
- * @param part 被加入的部分
- * @param isTrim 是否去除两端空白符
+ *
+ * @param list 列表
+ * @param part 被加入的部分
+ * @param isTrim 是否去除两端空白符
* @param ignoreEmpty 是否略过空字符串（空字符串不做为一个元素）
* @return 列表
*/
- private static List addToList(List list, String part, boolean isTrim, boolean ignoreEmpty){
- if(isTrim){
+ private static List addToList(List list, String part, boolean isTrim, boolean ignoreEmpty) {
+ if (isTrim) {
part = StrUtil.trim(part);
}
- if(false == ignoreEmpty || false == part.isEmpty()){
+ if (false == ignoreEmpty || false == part.isEmpty()) {
list.add(part);
}
return list;
}
-
+
/**
* List转Array
+ *
* @param list List
* @return Array
*/
- private static String[] toArray(List list){
+ private static String[] toArray(List list) {
return list.toArray(new String[0]);
}
//---------------------------------------------------------------------------------------------------------- Private method end
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/ftp/AbstractFtp.java b/hutool-extra/src/main/java/cn/hutool/extra/ftp/AbstractFtp.java
index a26c791a1..93d49343a 100644
--- a/hutool-extra/src/main/java/cn/hutool/extra/ftp/AbstractFtp.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/ftp/AbstractFtp.java
@@ -82,7 +82,12 @@ public abstract class AbstractFtp implements Closeable {
public boolean exist(String path) {
final String fileName = FileUtil.getName(path);
final String dir = StrUtil.removeSuffix(path, fileName);
- final List names = ls(dir);
+ final List names;
+ try{
+ names = ls(dir);
+ } catch (FtpException ignore){
+ return false;
+ }
return containsIgnoreCase(names, fileName);
}
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/ftp/Ftp.java b/hutool-extra/src/main/java/cn/hutool/extra/ftp/Ftp.java
index 4eaecc82d..60f8e99b1 100644
--- a/hutool-extra/src/main/java/cn/hutool/extra/ftp/Ftp.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/ftp/Ftp.java
@@ -346,7 +346,7 @@ public class Ftp extends AbstractFtp {
if (StrUtil.isNotBlank(path)) {
pwd = pwd();
if(false == cd(path)){
- throw new FtpException("Change dir to [{}] error, maybe path not exist!");
+ throw new FtpException("Change dir to [{}] error, maybe path not exist!", path);
}
}
@@ -410,7 +410,7 @@ public class Ftp extends AbstractFtp {
final String fileName = FileUtil.getName(path);
final String dir = StrUtil.removeSuffix(path, fileName);
if(false == cd(dir)){
- throw new FtpException("Change dir to [{}] error, maybe dir not exist!");
+ throw new FtpException("Change dir to [{}] error, maybe dir not exist!", path);
}
boolean isSuccess;
@@ -528,7 +528,7 @@ public class Ftp extends AbstractFtp {
if (StrUtil.isNotBlank(path)) {
mkDirs(path);
if (false == cd(path)) {
- throw new FtpException("Change dir to [{}] error, maybe dir not exist!");
+ throw new FtpException("Change dir to [{}] error, maybe dir not exist!", path);
}
}
@@ -636,7 +636,7 @@ public class Ftp extends AbstractFtp {
}
if(false == cd(path)){
- throw new FtpException("Change dir to [{}] error, maybe dir not exist!");
+ throw new FtpException("Change dir to [{}] error, maybe dir not exist!", path);
}
if (null != fileNameCharset) {