Source/BladeX-Tool/blade-core-tool/src/main/java/org/springblade/core/tool/support/StrSpliter.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,501 @@
package org.springblade.core.tool.support;

import org.springblade.core.tool.utils.Func;
import org.springblade.core.tool.utils.StringPool;
import org.springblade.core.tool.utils.StringUtil;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * å­—符串切分器
 *
 * @author Looly
 */
public class StrSpliter {

   //---------------------------------------------------------------------------------------------- Split by char

   /**
    * åˆ‡åˆ†å­—符串路径，仅支持Unix分界符：/
    *
    * @param str è¢«åˆ‡åˆ†çš„字符串
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.0.8
    */
   public static List<String> splitPath(String str) {
      return splitPath(str, 0);
   }

   /**
    * åˆ‡åˆ†å­—符串路径，仅支持Unix分界符：/
    *
    * @param str è¢«åˆ‡åˆ†çš„字符串
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.0.8
    */
   public static String[] splitPathToArray(String str) {
      return toArray(splitPath(str));
   }

   /**
    * åˆ‡åˆ†å­—符串路径，仅支持Unix分界符：/
    *
    * @param str   è¢«åˆ‡åˆ†çš„字符串
    * @param limit é™åˆ¶åˆ†ç‰‡æ•°
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.0.8
    */
   public static List<String> splitPath(String str, int limit) {
      return split(str, StringPool.SLASH, limit, true, true);
   }

   /**
    * åˆ‡åˆ†å­—符串路径，仅支持Unix分界符：/
    *
    * @param str   è¢«åˆ‡åˆ†çš„字符串
    * @param limit é™åˆ¶åˆ†ç‰‡æ•°
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.0.8
    */
   public static String[] splitPathToArray(String str, int limit) {
      return toArray(splitPath(str, limit));
   }

   /**
    * åˆ‡åˆ†å­—符串
    *
    * @param str         è¢«åˆ‡åˆ†çš„字符串
    * @param separator   åˆ†éš”符字符
    * @param ignoreEmpty æ˜¯å¦å¿½ç•¥ç©ºä¸²
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.2.1
    */
   public static List<String> splitTrim(String str, char separator, 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(String str, char separator, boolean isTrim, boolean ignoreEmpty) {
      return split(str, separator, 0, isTrim, ignoreEmpty);
   }

   /**
    * åˆ‡åˆ†å­—符串，大小写敏感，去除每个元素两边空白符
    *
    * @param str         è¢«åˆ‡åˆ†çš„字符串
    * @param separator   åˆ†éš”符字符
    * @param limit       é™åˆ¶åˆ†ç‰‡æ•°ï¼Œ-1不限制
    * @param ignoreEmpty æ˜¯å¦å¿½ç•¥ç©ºä¸²
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.0.8
    */
   public static List<String> 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 ignoreEmpty æ˜¯å¦å¿½ç•¥ç©ºä¸²
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.0.8
    */
   public static List<String> 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 ignoreEmpty æ˜¯å¦å¿½ç•¥ç©ºä¸²
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.2.1
    */
   public static List<String> 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 ignoreEmpty æ˜¯å¦å¿½ç•¥ç©ºä¸²
    * @param ignoreCase  æ˜¯å¦å¿½ç•¥å¤§å°å†™
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.2.1
    */
   public static List<String> split(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty, boolean ignoreCase) {
      if (StringUtil.isEmpty(str)) {
         return new ArrayList<String>(0);
      }
      if (limit == 1) {
         return addToList(new ArrayList<String>(1), str, isTrim, ignoreEmpty);
      }

      final ArrayList<String> list = new ArrayList<>(limit > 0 ? limit : 16);
      int len = str.length();
      int start = 0;
      for (int i = 0; i < len; i++) {
         if (Func.equals(separator, str.charAt(i))) {
            addToList(list, str.substring(start, i), isTrim, ignoreEmpty);
            start = i + 1;

            //检查是否超出范围（最大允许limit-1个，剩下一个留给末尾字符串）
            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 ignoreEmpty æ˜¯å¦å¿½ç•¥ç©ºä¸²
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.0.8
    */
   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 ignoreEmpty æ˜¯å¦å¿½ç•¥ç©ºä¸²
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.0.8
    */
   public static List<String> split(String str, String separator, boolean isTrim, 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(String str, String separator, boolean ignoreEmpty) {
      return split(str, separator, true, ignoreEmpty);
   }

   /**
    * åˆ‡åˆ†å­—符串，不忽略大小写
    *
    * @param str         è¢«åˆ‡åˆ†çš„字符串
    * @param separator   åˆ†éš”符字符串
    * @param limit       é™åˆ¶åˆ†ç‰‡æ•°
    * @param isTrim      æ˜¯å¦åŽ»é™¤åˆ‡åˆ†å­—符串后每个元素两边的空格
    * @param ignoreEmpty æ˜¯å¦å¿½ç•¥ç©ºä¸²
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.0.8
    */
   public static List<String> 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 ignoreEmpty æ˜¯å¦å¿½ç•¥ç©ºä¸²
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.2.1
    */
   public static List<String> 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 ignoreEmpty æ˜¯å¦å¿½ç•¥ç©ºä¸²
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.2.1
    */
   public static List<String> 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 ignoreEmpty æ˜¯å¦å¿½ç•¥ç©ºä¸²
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.2.1
    */
   public static List<String> 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 ignoreEmpty æ˜¯å¦å¿½ç•¥ç©ºä¸²
    * @param ignoreCase  æ˜¯å¦å¿½ç•¥å¤§å°å†™
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.2.1
    */
   public static List<String> split(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty, boolean ignoreCase) {
      if (StringUtil.isEmpty(str)) {
         return new ArrayList<String>(0);
      }
      if (limit == 1) {
         return addToList(new ArrayList<String>(1), str, isTrim, ignoreEmpty);
      }

      if (StringUtil.isEmpty(separator)) {
         return split(str, limit);
      } else if (separator.length() == 1) {
         return split(str, separator.charAt(0), limit, isTrim, ignoreEmpty, ignoreCase);
      }

      final ArrayList<String> list = new ArrayList<>();
      int len = str.length();
      int separatorLen = separator.length();
      int start = 0;
      int i = 0;
      while (i < len) {
         i = StringUtil.indexOf(str, separator, start, ignoreCase);
         if (i > -1) {
            addToList(list, str.substring(start, i), isTrim, ignoreEmpty);
            start = i + separatorLen;

            //检查是否超出范围（最大允许limit-1个，剩下一个留给末尾字符串）
            if (limit > 0 && list.size() > limit - 2) {
               break;
            }
         } else {
            break;
         }
      }
      return addToList(list, str.substring(start, len), isTrim, ignoreEmpty);
   }

   /**
    * åˆ‡åˆ†å­—符串为字符串数组
    *
    * @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) {
      return toArray(split(str, separator, limit, isTrim, ignoreEmpty));
   }

   //---------------------------------------------------------------------------------------------- Split by Whitespace

   /**
    * ä½¿ç”¨ç©ºç™½ç¬¦åˆ‡åˆ†å­—符串<br>
    * åˆ‡åˆ†åŽçš„字符串两边不包含空白符，空串或空白符串并不做为元素之一
    *
    * @param str   è¢«åˆ‡åˆ†çš„字符串
    * @param limit é™åˆ¶åˆ†ç‰‡æ•°
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.0.8
    */
   public static List<String> split(String str, int limit) {
      if (StringUtil.isEmpty(str)) {
         return new ArrayList<String>(0);
      }
      if (limit == 1) {
         return addToList(new ArrayList<String>(1), str, true, true);
      }

      final ArrayList<String> list = new ArrayList<>();
      int len = str.length();
      int start = 0;
      for (int i = 0; i < len; i++) {
         if (Func.isEmpty(str.charAt(i))) {
            addToList(list, str.substring(start, i), true, true);
            start = i + 1;
            if (limit > 0 && list.size() > limit - 2) {
               break;
            }
         }
      }
      return addToList(list, str.substring(start, len), true, true);
   }

   /**
    * åˆ‡åˆ†å­—符串为字符串数组
    *
    * @param str   è¢«åˆ‡åˆ†çš„字符串
    * @param limit é™åˆ¶åˆ†ç‰‡æ•°
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.0.8
    */
   public static String[] splitToArray(String str, int limit) {
      return toArray(split(str, limit));
   }

   //---------------------------------------------------------------------------------------------- Split by regex

   /**
    * é€šè¿‡æ­£åˆ™åˆ‡åˆ†å­—符串
    *
    * @param str              å­—符串
    * @param separatorPattern åˆ†éš”符正则{@link Pattern}
    * @param limit            é™åˆ¶åˆ†ç‰‡æ•°
    * @param isTrim           æ˜¯å¦åŽ»é™¤åˆ‡åˆ†å­—符串后每个元素两边的空格
    * @param ignoreEmpty      æ˜¯å¦å¿½ç•¥ç©ºä¸²
    * @return åˆ‡åˆ†åŽçš„集合
    * @since 3.0.8
    */
   public static List<String> split(String str, Pattern separatorPattern, int limit, boolean isTrim, boolean ignoreEmpty) {
      if (StringUtil.isEmpty(str)) {
         return new ArrayList<String>(0);
      }
      if (limit == 1) {
         return addToList(new ArrayList<String>(1), str, isTrim, ignoreEmpty);
      }

      if (null == separatorPattern) {
         return split(str, limit);
      }

      final Matcher matcher = separatorPattern.matcher(str);
      final ArrayList<String> list = new ArrayList<>();
      int len = str.length();
      int start = 0;
      while (matcher.find()) {
         addToList(list, str.substring(start, matcher.start()), isTrim, ignoreEmpty);
         start = matcher.end();

         if (limit > 0 && list.size() > limit - 2) {
            break;
         }
      }
      return addToList(list, str.substring(start, len), isTrim, ignoreEmpty);
   }

   /**
    * é€šè¿‡æ­£åˆ™åˆ‡åˆ†å­—符串为字符串数组
    *
    * @param str              è¢«åˆ‡åˆ†çš„字符串
    * @param separatorPattern åˆ†éš”符正则{@link Pattern}
    * @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) {
      return toArray(split(str, separatorPattern, limit, isTrim, ignoreEmpty));
   }

   //---------------------------------------------------------------------------------------------- Split by length

   /**
    * æ ¹æ®ç»™å®šé•¿åº¦ï¼Œå°†ç»™å®šå­—符串截取为多个部分
    *
    * @param str å­—符串
    * @param len æ¯ä¸€ä¸ªå°èŠ‚的长度
    * @return æˆªå–后的字符串数组
    */
   public static String[] splitByLength(String str, int len) {
      int partCount = str.length() / len;
      int lastPartCount = str.length() % len;
      int fixPart = 0;
      if (lastPartCount != 0) {
         fixPart = 1;
      }

      final String[] strs = new String[partCount + fixPart];
      for (int i = 0; i < partCount + fixPart; i++) {
         if (i == partCount + fixPart - 1 && lastPartCount != 0) {
            strs[i] = str.substring(i * len, i * len + lastPartCount);
         } else {
            strs[i] = str.substring(i * len, i * len + len);
         }
      }
      return strs;
   }

   //---------------------------------------------------------------------------------------------------------- Private method start

   /**
    * å°†å­—符串加入List中
    *
    * @param list        åˆ—表
    * @param part        è¢«åŠ å…¥çš„部分
    * @param isTrim      æ˜¯å¦åŽ»é™¤ä¸¤ç«¯ç©ºç™½ç¬¦
    * @param ignoreEmpty æ˜¯å¦ç•¥è¿‡ç©ºå­—符串（空字符串不做为一个元素）
    * @return åˆ—表
    */
   private static List<String> addToList(List<String> list, String part, boolean isTrim, boolean ignoreEmpty) {
      part = part.toString();
      if (isTrim) {
         part = part.trim();
      }
      if (false == ignoreEmpty || false == part.isEmpty()) {
         list.add(part);
      }
      return list;
   }

   /**
    * List转Array
    *
    * @param list List
    * @return Array
    */
   private static String[] toArray(List<String> list) {
      return list.toArray(new String[list.size()]);
   }
   //---------------------------------------------------------------------------------------------------------- Private method end
}