Package org.miaixz.bus.core.text

Class CharsBacker

java.lang.Object
org.miaixz.bus.core.text.CharsValidator
org.miaixz.bus.core.text.CharsBacker
Direct Known Subclasses:
StringKit
public class CharsBacker extends CharsValidator
CharSequence 相关类封装，包括但不限于：
  • 字符串补充前缀或后缀：addXXX
  • 字符串补充长度：padXXX
  • 字符串包含关系：containsXXX
  • 字符串默认值：defaultIfXXX
  • 字符串查找：indexOf
  • 字符串判断以什么结尾：endWith
  • 字符串判断以什么开始：startWith
  • 字符串匹配：equals
  • 字符串格式化：format
  • 字符串去除：removeXXX
  • 字符串重复：repeat
  • 获取子串：sub
  • 去除两边的指定字符串（只去除一次）：strip
  • 去除两边的指定所有字符：trim
  • 去除两边的指定所有字符包装和去除包装：wrap

需要注意的是，strip、trim、wrap（unWrap）的策略不同：

  • strip： 强调去除两边或某一边的指定字符串，这个字符串不会重复去除，如果一边不存在，另一边不影响去除
  • trim： 强调去除两边指定字符，如果这个字符有多个，全部去除，例如去除两边所有的空白符。
  • unWrap：强调去包装，要求包装的前后字符都要存在，只有一个则不做处理，如去掉双引号包装。
Since:
Java 17+
Author:
Kimi Liu

  • Constructor Details

    • CharsBacker

      public CharsBacker()

  • Method Details

    • toString

      public static String toString(Object obj)
      调用对象的toString方法，null会返回“null”
      Parameters:
      obj - 对象
      Returns:
      字符串
      See Also:

    • toStringOrNull

      public static String toStringOrNull(Object obj)
      调用对象的toString方法，null会返回null
      Parameters:
      obj - 对象
      Returns:
      字符串 or null

    • toStringOrEmpty

      public static String toStringOrEmpty(Object obj)
      调用对象的toString方法，null会返回空字符串 "" 如果仅仅是对CharSequence处理，请使用emptyIfNull(CharSequence)
      Parameters:
      obj - 对象
      Returns:
      String
      See Also:

    • emptyIfNull

      public static CharSequence emptyIfNull(CharSequence text)
      当给定字符串为空字符串时，转换为"" 此方法与toStringOrEmpty(Object)不同的是，如果提供的CharSequence非String，则保持原状
      Parameters:
      text - 被转换的字符串
      Returns:
      转换后的字符串
      See Also:

    • nullIfEmpty

      public static <T extends CharSequence> T nullIfEmpty(T text)
      当给定字符串为空字符串时，转换为null
      Type Parameters:
      T - 字符串类型
      Parameters:
      text - 被转换的字符串
      Returns:
      转换后的字符串

    • defaultIfNull

      public static <T extends CharSequence> T defaultIfNull(T text, T defaultValue)

      如果给定字符串为null返回默认值 

      
   defaultIfNull(null, null);       = null
   defaultIfNull(null, "");         = ""
   defaultIfNull(null, "zz");       = "zz"
   defaultIfNull("abc", *);         = "abc"
      Type Parameters:
      T - 字符串类型
      Parameters:
      text - 被检查字符串，可能为null
      defaultValue - 被检查字符串为null返回的默认值，可以为null
      Returns:
      被检查字符串不为 null 返回原值，否则返回默认值
      See Also:

    • defaultIfNull

      public static <T extends CharSequence> T defaultIfNull(T source, Supplier<? extends T> defaultSupplier)
      如果给定字符串不为null 返回原值, 否则返回 Supplier.get() 提供的默认值
      Type Parameters:
      T - 被检查字符串类型
      Parameters:
      source - 被检查字符串，可能为null
      defaultSupplier - 为空时的默认值提供者
      Returns:
      被检查字符串不为 null 返回原值，否则返回 Supplier.get() 提供的默认值
      See Also:

    • defaultIfNull

      public static <T extends CharSequence, R> R defaultIfNull(T source, Function<? super T,? extends R> handler, Supplier<? extends R> defaultSupplier)
      如果给定字符串不为null 返回自定义handler处理后的结果，否则返回 Supplier.get() 提供的默认值
      Type Parameters:
      T - 被检查对象类型
      R - 返回值类型
      Parameters:
      source - 被检查对象，可能为null
      handler - 非空时自定义的处理方法
      defaultSupplier - 为空时的默认值提供者
      Returns:
      被检查对象不为 null 返回处理后的结果，否则返回 Supplier.get() 提供的默认值
      See Also:

    • defaultIfEmpty

      public static <T extends CharSequence> T defaultIfEmpty(T text, T defaultValue)
      如果给定对象为null或者 "" 返回默认值 
         defaultIfEmpty(null, null)      = null
   defaultIfEmpty(null, "")        = ""
   defaultIfEmpty("", "zz")        = "zz"
   defaultIfEmpty(" ", "zz")       = " "
   defaultIfEmpty("abc", *)        = "abc"
      Type Parameters:
      T - 对象类型（必须实现CharSequence接口）
      Parameters:
      text - 被检查对象，可能为null
      defaultValue - 被检查对象为null或者 ""返回的默认值，可以为null或者 ""
      Returns:
      被检查对象为null或者 ""返回默认值，否则返回原值

    • defaultIfEmpty

      public static <T extends CharSequence> T defaultIfEmpty(T text, Supplier<? extends T> defaultSupplier)
      如果给定对象为null或者""返回原值, 否则返回自定义handler处理后的返回值
      Type Parameters:
      T - 被检查对象类型
      Parameters:
      text - String 类型
      defaultSupplier - empty时的处理方法
      Returns:
      处理后的返回值

    • defaultIfEmpty

      public static <T extends CharSequence, V> V defaultIfEmpty(T text, Function<T,V> handler, Supplier<? extends V> defaultSupplier)
      如果给定对象为null或者""返回defaultHandler处理的结果, 否则返回自定义handler处理后的返回值
      Type Parameters:
      T - 被检查对象类型
      V - 结果类型
      Parameters:
      text - String 类型
      handler - 非empty的处理方法
      defaultSupplier - empty时的处理方法
      Returns:
      处理后的返回值

    • defaultIfBlank

      public static <T extends CharSequence> T defaultIfBlank(T text, T defaultValue)
      如果给定对象为null或者""或者空白符返回默认值 
         defaultIfBlank(null, null)      = null
   defaultIfBlank(null, "")        = ""
   defaultIfBlank("", "zz")        = "zz"
   defaultIfBlank(" ", "zz")       = "zz"
   defaultIfBlank("abc", *)        = "abc"
      Type Parameters:
      T - 对象类型（必须实现CharSequence接口）
      Parameters:
      text - 被检查对象，可能为null
      defaultValue - 被检查对象为null或者 ""或者空白符返回的默认值，可以为null或者 ""或者空白符
      Returns:
      被检查对象为null或者 ""或者空白符返回默认值，否则返回原值

    • defaultIfBlank

      public static <T extends CharSequence, V> V defaultIfBlank(T text, Function<T,V> handler, Supplier<? extends V> defaultSupplier)
      如果被检查对象为 null 或 "" 或 空白字符串时，返回默认值（由 defaultValueSupplier 提供）；否则直接返回
      Type Parameters:
      T - 对象类型（必须实现CharSequence接口）
      V - 结果类型
      Parameters:
      text - 被检查对象
      handler - 非blank的处理方法
      defaultSupplier - 默认值提供者
      Returns:
      被检查对象为null返回默认值，否则返回自定义handle处理后的返回值
      Throws:
      NullPointerException - defaultValueSupplier == null 时，抛出

    • trim

      public static String trim(CharSequence text)
      除去字符串头尾部的空白，如果字符串是null，依然返回null。

      注意，和String.trim()不同，此方法使用CharKit.isBlankChar(char) 来判定空白， 因而可以除去英文字符集之外的其它空白，如中文空格。 

       trim(null)                         = null
 trim("")                 = ""
 trim("     ")            = ""
 trim("abc")              = "abc"
 trim("    abc    ")      = "abc"
      Parameters:
      text - 要处理的字符串
      Returns:
      除去头尾空白的字符串，如果原字串为null，则返回null

    • trimToEmpty

      public static String trimToEmpty(CharSequence text)
      除去字符串头尾部的空白，如果字符串是null，返回""。 
       trimToEmpty(null)                  = ""
 trimToEmpty("")                    = ""
 trimToEmpty("     ")               = ""
 trimToEmpty("abc")                 = "abc"
 trimToEmpty("    abc    ")         = "abc"
      Parameters:
      text - 字符串
      Returns:
      去除两边空白符后的字符串, 如果为null返回""

    • trimToNull

      public static String trimToNull(CharSequence text)
      除去字符串头尾部的空白，如果字符串是null或者""，返回null。 
       trimToNull(null)                   = null
 trimToNull("")                     = null
 trimToNull("     ")                = null
 trimToNull("abc")                  = "abc"
 trimToEmpty("    abc    ")         = "abc"
      Parameters:
      text - 字符串
      Returns:
      去除两边空白符后的字符串, 如果为空返回null

    • trimPrefix

      public static String trimPrefix(CharSequence text)
      除去字符串头部的空白，如果字符串是null，则返回null。

      注意，和String.trim()不同，此方法使用CharKit.isBlankChar(char) 来判定空白， 因而可以除去英文字符集之外的其它空白，如中文空格。 

       trimPrefix(null)                   = null
 trimPrefix("")           = ""
 trimPrefix("abc")        = "abc"
 trimPrefix("  abc")      = "abc"
 trimPrefix("abc  ")      = "abc  "
 trimPrefix(" abc ")      = "abc "
      Parameters:
      text - 要处理的字符串
      Returns:
      除去空白的字符串，如果原字串为null或结果字符串为""，则返回 null

    • trimSuffix

      public static String trimSuffix(CharSequence text)
      除去字符串尾部的空白，如果字符串是null，则返回null。

      注意，和String.trim()不同，此方法使用CharKit.isBlankChar(char) 来判定空白， 因而可以除去英文字符集之外的其它空白，如中文空格。 

       trimSuffix(null)                  = null
 trimSuffix("")          = ""
 trimSuffix("abc")       = "abc"
 trimSuffix("  abc")     = "  abc"
 trimSuffix("abc  ")     = "abc"
 trimSuffix(" abc ")     = " abc"
      Parameters:
      text - 要处理的字符串
      Returns:
      除去空白的字符串，如果原字串为null或结果字符串为""，则返回 null

    • trim

      public static String trim(CharSequence text, StringTrimer.TrimMode mode)
      除去字符串头尾部的空白符，如果字符串是null，依然返回null。
      Parameters:
      text - 要处理的字符串
      mode - 去除模式，可选去除头部、尾部、两边
      Returns:
      除去指定字符后的的字符串，如果原字串为null，则返回null

    • trim

      public static String trim(CharSequence text, StringTrimer.TrimMode mode, Predicate<Character> predicate)
      按照断言，除去字符串头尾部的断言为真的字符，如果字符串是null，依然返回null。
      Parameters:
      text - 要处理的字符串
      mode - 去除模式，可选去除头部、尾部、两边
      predicate - 断言是否过掉字符，返回true表述过滤掉，false表示不过滤
      Returns:
      除去指定字符后的的字符串，如果原字串为null，则返回null

    • startWith

      public static boolean startWith(CharSequence text, char c)
      字符串是否以给定字符开始
      Parameters:
      text - 字符串
      c - 字符
      Returns:
      是否开始

    • startWith

      public static boolean startWith(CharSequence text, CharSequence prefix)
      是否以指定字符串开头
      Parameters:
      text - 被监测字符串
      prefix - 开头字符串
      Returns:
      是否以指定字符串开头

    • startWithIgnoreEquals

      public static boolean startWithIgnoreEquals(CharSequence text, CharSequence prefix)
      是否以指定字符串开头，忽略相等字符串的情况
      Parameters:
      text - 被监测字符串
      prefix - 开头字符串
      Returns:
      是否以指定字符串开头并且两个字符串不相等

    • startWithIgnoreCase

      public static boolean startWithIgnoreCase(CharSequence text, CharSequence prefix)
      是否以指定字符串开头，忽略大小写
      Parameters:
      text - 被监测字符串
      prefix - 开头字符串
      Returns:
      是否以指定字符串开头

    • startWithAny

      public static boolean startWithAny(CharSequence text, CharSequence... prefixes)
      给定字符串是否以任何一个字符串开始 给定字符串和数组为空都返回false
      Parameters:
      text - 给定字符串
      prefixes - 需要检测的开始字符串
      Returns:
      给定字符串是否以任何一个字符串开始

    • startWithAnyIgnoreCase

      public static boolean startWithAnyIgnoreCase(CharSequence text, CharSequence... prefixes)
      给定字符串是否以任何一个字符串开始（忽略大小写） 给定字符串和数组为空都返回false
      Parameters:
      text - 给定字符串
      prefixes - 需要检测的开始字符串
      Returns:
      给定字符串是否以任何一个字符串开始

    • startWith

      public static boolean startWith(CharSequence text, CharSequence prefix, boolean ignoreCase)
      是否以指定字符串开头 如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
      Parameters:
      text - 被监测字符串
      prefix - 开头字符串
      ignoreCase - 是否忽略大小写
      Returns:
      是否以指定字符串开头

    • startWith

      public static boolean startWith(CharSequence text, CharSequence prefix, boolean ignoreCase, boolean ignoreEquals)
      是否以指定字符串开头 如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false 
           CharsBacker.startWith("123", "123", false, true);   -- false
     CharsBacker.startWith("ABCDEF", "abc", true, true); -- true
     CharsBacker.startWith("abc", "abc", true, true);    -- false
      Parameters:
      text - 被监测字符串
      prefix - 开头字符串
      ignoreCase - 是否忽略大小写
      ignoreEquals - 是否忽略字符串相等的情况
      Returns:
      是否以指定字符串开头

    • endWith

      public static boolean endWith(CharSequence text, char c)
      字符串是否以给定字符结尾
      Parameters:
      text - 字符串
      c - 字符
      Returns:
      是否结尾

    • endWith

      public static boolean endWith(CharSequence text, CharSequence suffix)
      是否以指定字符串结尾
      Parameters:
      text - 被监测字符串
      suffix - 结尾字符串
      Returns:
      是否以指定字符串结尾

    • endWithIgnoreCase

      public static boolean endWithIgnoreCase(CharSequence text, CharSequence suffix)
      是否以指定字符串结尾，忽略大小写
      Parameters:
      text - 被监测字符串
      suffix - 结尾字符串
      Returns:
      是否以指定字符串结尾

    • endWithAny

      public static boolean endWithAny(CharSequence text, CharSequence... suffixes)
      给定字符串是否以任何一个字符串结尾 给定字符串和数组为空都返回false
      Parameters:
      text - 给定字符串
      suffixes - 需要检测的结尾字符串
      Returns:
      给定字符串是否以任何一个字符串结尾

    • endWithAnyIgnoreCase

      public static boolean endWithAnyIgnoreCase(CharSequence text, CharSequence... suffixes)
      给定字符串是否以任何一个字符串结尾（忽略大小写） 给定字符串和数组为空都返回false
      Parameters:
      text - 给定字符串
      suffixes - 需要检测的结尾字符串
      Returns:
      给定字符串是否以任何一个字符串结尾

    • endWith

      public static boolean endWith(CharSequence text, CharSequence suffix, boolean ignoreCase)
      是否以指定字符串结尾 如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
      Parameters:
      text - 被监测字符串
      suffix - 结尾字符串
      ignoreCase - 是否忽略大小写
      Returns:
      是否以指定字符串结尾

    • endWith

      public static boolean endWith(CharSequence text, CharSequence suffix, boolean ignoreCase, boolean ignoreEquals)
      是否以指定字符串结尾 如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
      Parameters:
      text - 被监测字符串
      suffix - 结尾字符串
      ignoreCase - 是否忽略大小写
      ignoreEquals - 是否忽略字符串相等的情况
      Returns:
      是否以指定字符串结尾

    • contains

      public static boolean contains(CharSequence text, char args)
      指定字符是否在字符串中出现过
      Parameters:
      text - 字符串
      args - 被查找的字符
      Returns:
      是否包含

    • contains

      public static boolean contains(CharSequence text, CharSequence args)
      指定字符串是否在字符串中出现过
      Parameters:
      text - 字符串
      args - 被查找的字符串
      Returns:
      是否包含

    • containsAny

      public static boolean containsAny(CharSequence text, CharSequence... args)
      查找指定字符串是否包含指定字符串列表中的任意一个字符串
      Parameters:
      text - 指定字符串
      args - 需要检查的字符串数组
      Returns:
      是否包含任意一个字符串

    • containsAny

      public static boolean containsAny(CharSequence text, char... args)
      查找指定字符串是否包含指定字符列表中的任意一个字符
      Parameters:
      text - 指定字符串
      args - 需要检查的字符数组
      Returns:
      是否包含任意一个字符

    • containsOnly

      public static boolean containsOnly(CharSequence text, char... args)
      检查指定字符串中是否只包含给定的字符 这里的containsOnly并不是必须全部给定的args都需要有，而是一个子集。 args是个限定集合，检查字符串中的字符是否在这个限定集合中。
      • text 是 null，args 也是 null，直接返回 true
      • text 是 null，args 不是 null，直接返回 true
      • text 不是 null，args 是 null，直接返回 false
      Parameters:
      text - 字符串
      args - 检查的字符
      Returns:
      字符串含有非检查的字符，返回false

    • containsBlank

      public static boolean containsBlank(CharSequence text)
      给定字符串是否包含空白符（空白符包括空格、制表符、全角空格和不间断空格） 如果给定字符串为null或者""，则返回false
      Parameters:
      text - 字符串
      Returns:
      是否包含空白符

    • getContainsString

      public static String getContainsString(CharSequence text, CharSequence... args)
      查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串
      Parameters:
      text - 指定字符串
      args - 需要检查的字符串数组
      Returns:
      被包含的第一个字符串

    • containsIgnoreCase

      public static boolean containsIgnoreCase(CharSequence text, CharSequence args)
      是否包含特定字符，忽略大小写，如果给定两个参数都为null，返回true
      Parameters:
      text - 被检测字符串
      args - 被测试是否包含的字符串
      Returns:
      是否包含

    • containsAnyIgnoreCase

      public static boolean containsAnyIgnoreCase(CharSequence text, CharSequence... args)
      查找指定字符串是否包含指定字符串列表中的任意一个字符串 忽略大小写
      Parameters:
      text - 指定字符串
      args - 需要检查的字符串数组
      Returns:
      是否包含任意一个字符串

    • getContainsStrIgnoreCase

      public static String getContainsStrIgnoreCase(CharSequence text, CharSequence... args)
      查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串 忽略大小写
      Parameters:
      text - 指定字符串
      args - 需要检查的字符串数组
      Returns:
      被包含的第一个字符串

    • containsAll

      public static boolean containsAll(CharSequence text, CharSequence... args)
      检查指定字符串中是否含给定的所有字符串
      Parameters:
      text - 字符串
      args - 检查的字符
      Returns:
      字符串含有非检查的字符，返回false

    • indexOf

      public static int indexOf(CharSequence text, char args)
      指定范围内查找指定字符
      Parameters:
      text - 字符串
      args - 被查找的字符
      Returns:
      位置

    • indexOf

      public static int indexOf(CharSequence text, char args, int start)
      指定范围内查找指定字符
      Parameters:
      text - 字符串
      args - 被查找的字符
      start - 起始位置，如果小于0，从0开始查找
      Returns:
      位置

    • indexOf

      public static int indexOf(CharSequence text, char args, int start, int end)
      指定范围内查找指定字符
      Parameters:
      text - 字符串
      args - 被查找的字符
      start - 起始位置，如果小于0，从0开始查找
      end - 终止位置，如果超过str.length()则默认查找到字符串末尾
      Returns:
      位置

    • indexOf

      public static int indexOf(CharSequence text, Predicate<Character> matcher, int start, int end)
      指定范围内查找指定字符
      Parameters:
      text - 字符串
      matcher - 被查找的字符匹配器
      start - 起始位置，如果小于0，从0开始查找
      end - 终止位置，如果超过str.length()则默认查找到字符串末尾
      Returns:
      位置

    • indexOfIgnoreCase

      public static int indexOfIgnoreCase(CharSequence text, CharSequence args)
      指定范围内查找字符串，忽略大小写 
       indexOfIgnoreCase(null, *, *)          = -1
 indexOfIgnoreCase(*, null, *)          = -1
 indexOfIgnoreCase("", "", 0)           = 0
 indexOfIgnoreCase("aabaabaa", "A", 0)  = 0
 indexOfIgnoreCase("aabaabaa", "B", 0)  = 2
 indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
 indexOfIgnoreCase("aabaabaa", "B", 3)  = 5
 indexOfIgnoreCase("aabaabaa", "B", 9)  = -1
 indexOfIgnoreCase("aabaabaa", "B", -1) = 2
 indexOfIgnoreCase("aabaabaa", "", 2)   = 2
 indexOfIgnoreCase("abc", "", 9)        = -1
      Parameters:
      text - 字符串
      args - 需要查找位置的字符串
      Returns:
      位置

    • indexOfIgnoreCase

      public static int indexOfIgnoreCase(CharSequence text, CharSequence args, int fromIndex)
      指定范围内查找字符串 
       indexOfIgnoreCase(null, *, *)          = -1
 indexOfIgnoreCase(*, null, *)          = -1
 indexOfIgnoreCase("", "", 0)           = 0
 indexOfIgnoreCase("aabaabaa", "A", 0)  = 0
 indexOfIgnoreCase("aabaabaa", "B", 0)  = 2
 indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
 indexOfIgnoreCase("aabaabaa", "B", 3)  = 5
 indexOfIgnoreCase("aabaabaa", "B", 9)  = -1
 indexOfIgnoreCase("aabaabaa", "B", -1) = 2
 indexOfIgnoreCase("aabaabaa", "", 2)   = 2
 indexOfIgnoreCase("abc", "", 9)        = -1
      Parameters:
      text - 字符串
      args - 需要查找位置的字符串
      fromIndex - 起始位置
      Returns:
      位置

    • indexOf

      public static int indexOf(CharSequence text, CharSequence args, int from, boolean ignoreCase)
      指定范围内查找字符串
      Parameters:
      text - 字符串，空则返回-1
      args - 需要查找位置的字符串，空则返回-1
      from - 起始位置（包含）
      ignoreCase - 是否忽略大小写
      Returns:
      位置

    • lastIndexOfIgnoreCase

      public static int lastIndexOfIgnoreCase(CharSequence text, CharSequence args)
      指定范围内查找字符串，忽略大小写
      Parameters:
      text - 字符串
      args - 需要查找位置的字符串
      Returns:
      位置

    • lastIndexOfIgnoreCase

      public static int lastIndexOfIgnoreCase(CharSequence text, CharSequence args, int fromIndex)
      指定范围内查找字符串，忽略大小写 fromIndex 为搜索起始位置，从后往前计数
      Parameters:
      text - 字符串
      args - 需要查找位置的字符串
      fromIndex - 起始位置，从后往前计数
      Returns:
      位置

    • lastIndexOf

      public static int lastIndexOf(CharSequence text, CharSequence args, int from, boolean ignoreCase)
      指定范围内查找字符串 fromIndex 为搜索起始位置，从后往前计数
      Parameters:
      text - 字符串
      args - 需要查找位置的字符串
      from - 起始位置，从后往前计数
      ignoreCase - 是否忽略大小写
      Returns:
      位置

    • ordinalIndexOf

      public static int ordinalIndexOf(CharSequence text, CharSequence args, int ordinal)
      返回字符串 args 在字符串 text1 中第 ordinal 次出现的位置。

      如果 text1=null 或 args=null 或 ordinal≤0 则返回-1 此方法来自：Apache-Commons-Lang

      示例（*代表任意字符）： 

       ordinalIndexOf(null, *, *)          = -1
 ordinalIndexOf(*, null, *)          = -1
 ordinalIndexOf("", "", *)           = 0
 ordinalIndexOf("aabaabaa", "a", 1)  = 0
 ordinalIndexOf("aabaabaa", "a", 2)  = 1
 ordinalIndexOf("aabaabaa", "b", 1)  = 2
 ordinalIndexOf("aabaabaa", "b", 2)  = 5
 ordinalIndexOf("aabaabaa", "ab", 1) = 1
 ordinalIndexOf("aabaabaa", "ab", 2) = 4
 ordinalIndexOf("aabaabaa", "", 1)   = 0
 ordinalIndexOf("aabaabaa", "", 2)   = 0
      Parameters:
      text - 被检查的字符串，可以为null
      args - 被查找的字符串，可以为null
      ordinal - 第几次出现的位置
      Returns:
      查找到的位置

    • removeAll

      public static String removeAll(CharSequence text, CharSequence args)
      移除字符串中所有给定字符串 例：removeAll("aa-bb-cc-dd", "-") = aabbccdd
      Parameters:
      text - 字符串
      args - 被移除的字符串
      Returns:
      移除后的字符串

    • removeAny

      public static String removeAny(CharSequence text, CharSequence... args)
      移除字符串中所有给定字符串，当某个字符串出现多次，则全部移除 例：removeAny("aa-bb-cc-dd", "a", "b") = --cc-dd
      Parameters:
      text - 字符串
      args - 被移除的字符串
      Returns:
      移除后的字符串

    • removeAll

      public static String removeAll(CharSequence text, char... chars)
      去除字符串中指定的多个字符，如有多个则全部去除
      Parameters:
      text - 字符串
      chars - 字符列表
      Returns:
      去除后的字符

    • removeAllLineBreaks

      public static String removeAllLineBreaks(CharSequence text)
      去除所有换行符，包括： 
       1. \r
 1. \n
      Parameters:
      text - 字符串
      Returns:
      处理后的字符串

    • removePreAndLowerFirst

      public static String removePreAndLowerFirst(CharSequence text, int preLength)
      去掉首部指定长度的字符串并将剩余字符串首字母小写 例如：text1=setName, preLength=3 = return name
      Parameters:
      text - 被处理的字符串
      preLength - 去掉的长度
      Returns:
      处理后的字符串，不符合规范返回null

    • removePreAndLowerFirst

      public static String removePreAndLowerFirst(CharSequence text, CharSequence prefix)
      去掉首部指定长度的字符串并将剩余字符串首字母小写 例如：text1=setName, prefix=set = return name
      Parameters:
      text - 被处理的字符串
      prefix - 前缀
      Returns:
      处理后的字符串，不符合规范返回null

    • removePrefix

      public static String removePrefix(CharSequence text, CharSequence prefix)
      去掉指定前缀
      Parameters:
      text - 字符串
      prefix - 前缀
      Returns:
      切掉后的字符串，若前缀不是 prefix， 返回原字符串

    • removePrefixIgnoreCase

      public static String removePrefixIgnoreCase(CharSequence text, CharSequence prefix)
      忽略大小写去掉指定前缀
      Parameters:
      text - 字符串
      prefix - 前缀
      Returns:
      切掉后的字符串，若前缀不是 prefix， 返回原字符串

    • removePrefix

      public static String removePrefix(CharSequence text, CharSequence prefix, boolean ignoreCase)
      去掉指定前缀
      Parameters:
      text - 字符串
      prefix - 前缀
      ignoreCase - 是否忽略大小写
      Returns:
      切掉后的字符串，若前缀不是 prefix， 返回原字符串

    • removeAllSuffix

      public static String removeAllSuffix(CharSequence text, CharSequence suffix)
      去掉指定所有后缀，如： 
      
     str=11abab, suffix=ab => return 11
     str=11ab, suffix=ab => return 11
     str=11ab, suffix="" => return 11ab
     str=11ab, suffix=null => return 11ab
      Parameters:
      text - 字符串，空返回原字符串
      suffix - 后缀字符串，空返回原字符串
      Returns:
      去掉所有后缀的字符串，若后缀不是 suffix， 返回原字符串

    • removeSuffix

      public static String removeSuffix(CharSequence text, CharSequence suffix)
      去掉指定后缀
      Parameters:
      text - 字符串
      suffix - 后缀
      Returns:
      切掉后的字符串，若后缀不是 suffix， 返回原字符串

    • removeSufAndLowerFirst

      public static String removeSufAndLowerFirst(CharSequence text, CharSequence suffix)
      去掉指定后缀，并小写首字母
      Parameters:
      text - 字符串
      suffix - 后缀
      Returns:
      切掉后的字符串，若后缀不是 suffix， 返回原字符串

    • removeSuffixIgnoreCase

      public static String removeSuffixIgnoreCase(CharSequence text, CharSequence suffix)
      忽略大小写去掉指定后缀
      Parameters:
      text - 字符串
      suffix - 后缀
      Returns:
      切掉后的字符串，若后缀不是 suffix， 返回原字符串

    • cleanBlank

      public static String cleanBlank(CharSequence text)
      清理空白字符
      Parameters:
      text - 被清理的字符串
      Returns:
      清理后的字符串

    • strip

      public static String strip(CharSequence text, CharSequence prefixOrSuffix)
      去除两边的指定字符串
      Parameters:
      text - 被处理的字符串
      prefixOrSuffix - 前缀或后缀
      Returns:
      处理后的字符串

    • strip

      public static String strip(CharSequence text, CharSequence prefix, CharSequence suffix)
      去除两边的指定字符串 两边字符如果存在，则去除，不存在不做处理
      Parameters:
      text - 被处理的字符串
      prefix - 前缀
      suffix - 后缀
      Returns:
      处理后的字符串

    • strip

      public static String strip(CharSequence text, CharSequence prefix, CharSequence suffix, boolean ignoreCase)
      去除两边的指定字符串 两边字符如果存在，则去除，不存在不做处理 
      
  "aaa_STRIPPED_bbb", "a", "b"       -> "aa_STRIPPED_bb"
  "aaa_STRIPPED_bbb", null, null     -> "aaa_STRIPPED_bbb"
  "aaa_STRIPPED_bbb", "", ""         -> "aaa_STRIPPED_bbb"
  "aaa_STRIPPED_bbb", "", "b"        -> "aaa_STRIPPED_bb"
  "aaa_STRIPPED_bbb", null, "b"      -> "aaa_STRIPPED_bb"
  "aaa_STRIPPED_bbb", "a", ""        -> "aa_STRIPPED_bbb"
  "aaa_STRIPPED_bbb", "a", null      -> "aa_STRIPPED_bbb"

  "a", "a", "a"  -> ""
      Parameters:
      text - 被处理的字符串
      prefix - 前缀
      suffix - 后缀
      ignoreCase - 是否忽略大小写
      Returns:
      处理后的字符串

    • stripIgnoreCase

      public static String stripIgnoreCase(CharSequence text, CharSequence prefixOrSuffix)
      去除两边的指定字符串，忽略大小写
      Parameters:
      text - 被处理的字符串
      prefixOrSuffix - 前缀或后缀
      Returns:
      处理后的字符串

    • stripIgnoreCase

      public static String stripIgnoreCase(CharSequence text, CharSequence prefix, CharSequence suffix)
      去除两边的指定字符串，忽略大小写
      Parameters:
      text - 被处理的字符串
      prefix - 前缀
      suffix - 后缀
      Returns:
      处理后的字符串

    • addPrefixIfNot

      public static String addPrefixIfNot(CharSequence text, CharSequence prefix)
      如果给定字符串不是以prefix开头的，在开头补充 prefix
      Parameters:
      text - 字符串
      prefix - 前缀
      Returns:
      补充后的字符串
      See Also:

    • addSuffixIfNot

      public static String addSuffixIfNot(CharSequence text, CharSequence suffix)
      如果给定字符串不是以suffix结尾的，在尾部补充 suffix
      Parameters:
      text - 字符串
      suffix - 后缀
      Returns:
      补充后的字符串
      See Also:

    • cut

      public static String[] cut(CharSequence text, int partLength)
      将字符串切分为N等份
      Parameters:
      text - 字符串
      partLength - 每等份的长度
      Returns:
      切分后的数组

    • sub

      public static String sub(CharSequence text, int fromIndexInclude, int toIndexExclude)
      改进JDK subString
      • index从0开始计算，最后一个字符为-1，即sub("miaixz", 0, -1)得到"miaixz"
      • 如果from和to位置一样，返回 ""
      • 如果from或to为负数，则按照length从后向前数位置，如果绝对值大于字符串长度，则from归到0，to归到length
      • 如果经过修正的index中from大于to，则互换from和to，如abcdefgh 2 3 =》 c，abcdefgh 2 -3 =》 cde
      Parameters:
      text - String
      fromIndexInclude - 开始的index（包括）
      toIndexExclude - 结束的index（不包括）
      Returns:
      字串

    • subByCodePoint

      public static String subByCodePoint(CharSequence text, int fromIndex, int toIndex)
      通过CodePoint截取字符串，可以截断Emoji
      Parameters:
      text - String
      fromIndex - 开始的index（包括）
      toIndex - 结束的index（不包括）
      Returns:
      字串

    • subPreGbk

      public static String subPreGbk(CharSequence text, int len, CharSequence suffix)
      截取部分字符串，这里一个汉字的长度认为是2
      Parameters:
      text - 字符串
      len - bytes切割到的位置（包含）
      suffix - 切割后加上后缀
      Returns:
      切割后的字符串

    • subPreGbk

      public static String subPreGbk(CharSequence text, int len, boolean halfUp)
      截取部分字符串，这里一个汉字的长度认为是2 可以自定义halfUp，如len为10，如果截取后最后一个字符是半个字符，true表示保留，则长度是11，否则长度9
      Parameters:
      text - 字符串
      len - bytes切割到的位置（包含）
      halfUp - 遇到截取一半的GBK字符，是否保留。
      Returns:
      切割后的字符串

    • subPre

      public static String subPre(CharSequence text, int toIndexExclude)
      切割指定位置之前部分的字符串 安全的subString,允许：string为null，允许string长度小于toIndexExclude长度 
      
 Assert.assertEquals(subPre(null, 3), null);
 Assert.assertEquals(subPre("ab", 3), "ab");
 Assert.assertEquals(subPre("abc", 3), "abc");
 Assert.assertEquals(subPre("abcd", 3), "abc");
 Assert.assertEquals(subPre("abcd", -3), "a");
 Assert.assertEquals(subPre("ab", 3), "ab");
      Parameters:
      text - 字符串
      toIndexExclude - 切割到的位置（不包括）
      Returns:
      切割后的剩余的前半部分字符串

    • subSuf

      public static String subSuf(CharSequence text, int fromIndex)
      切割指定位置之后部分的字符串
      • fromIndex为0或字符串为空，返回原字符串
      • fromIndex大于字符串本身的长度，返回""
      • fromIndex支持负数，-1表示length-1
      Parameters:
      text - 字符串
      fromIndex - 切割开始的位置（包括）
      Returns:
      切割后后剩余的后半部分字符串

    • subSufByLength

      public static String subSufByLength(CharSequence text, int length)
      切割指定长度的后部分的字符串 
       subSufByLength("abcde", 3)      =    "cde"
 subSufByLength("abcde", 0)      =    ""
 subSufByLength("abcde", -5)     =    ""
 subSufByLength("abcde", -1)     =    ""
 subSufByLength("abcde", 5)       =    "abcde"
 subSufByLength("abcde", 10)     =    "abcde"
 subSufByLength(null, 3)               =    null
      Parameters:
      text - 字符串
      length - 切割长度
      Returns:
      切割后后剩余的后半部分字符串

    • subByLength

      public static String subByLength(String input, int fromIndex, int length)
      截取字符串,从指定位置开始,截取指定长度的字符串 当fromIndex为正数时，这个index指的是插空位置，如下： 
           0   1   2   3   4
       A   B   C   D
      当fromIndex为负数时，为反向插空位置，其中-1表示最后一个字符之前的位置： 
             -3   -2   -1   length
     A    B    C    D
      Parameters:
      input - 原始字符串
      fromIndex - 开始的index,包括，可以为负数
      length - 要截取的长度
      Returns:
      截取后的字符串

    • subBefore

      public static String subBefore(CharSequence text, CharSequence separator, boolean isLastSeparator)
      截取分隔字符串之前的字符串，不包括分隔字符串 如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串 如果分隔字符串为空串""，则返回空串，如果分隔字符串未找到，返回原字符串，举例如下： 
       subBefore(null, *, false)      = null
 subBefore("", *, false)        = ""
 subBefore("abc", "a", false)   = ""
 subBefore("abcba", "b", false) = "a"
 subBefore("abc", "c", false)   = "ab"
 subBefore("abc", "d", false)   = "abc"
 subBefore("abc", "", false)    = ""
 subBefore("abc", null, false)  = "abc"
      Parameters:
      text - 被查找的字符串
      separator - 分隔字符串（不包括）
      isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
      Returns:
      切割后的字符串

    • subBefore

      public static String subBefore(CharSequence text, char separator, boolean isLastSeparator)
      截取分隔字符串之前的字符串，不包括分隔字符串 如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串 如果分隔字符串未找到，返回原字符串，举例如下： 
       subBefore(null, *, false)      = null
 subBefore("", *, false)        = ""
 subBefore("abc", 'a', false)   = ""
 subBefore("abcba", 'b', false) = "a"
 subBefore("abc", 'c', false)   = "ab"
 subBefore("abc", 'd', false)   = "abc"
      Parameters:
      text - 被查找的字符串
      separator - 分隔字符串（不包括）
      isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
      Returns:
      切割后的字符串

    • subAfter

      public static String subAfter(CharSequence text, CharSequence separator, boolean isLastSeparator)
      截取分隔字符串之后的字符串，不包括分隔字符串 如果给定的字符串为空串（null或""），返回原字符串 如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下： 
       subAfter(null, *, false)      = null
 subAfter("", *, false)        = ""
 subAfter(*, null, false)      = ""
 subAfter("abc", "a", false)   = "ciphers"
 subAfter("abcba", "b", false) = "cba"
 subAfter("abc", "c", false)   = ""
 subAfter("abc", "d", false)   = ""
 subAfter("abc", "", false)    = "abc"
      Parameters:
      text - 被查找的字符串
      separator - 分隔字符串（不包括）
      isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
      Returns:
      切割后的字符串

    • subAfter

      public static String subAfter(CharSequence text, char separator, boolean isLastSeparator)
      截取分隔字符串之后的字符串，不包括分隔字符串 如果给定的字符串为空串（null或""），返回原字符串 如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串，举例如下： 
       subAfter(null, *, false)      = null
 subAfter("", *, false)        = ""
 subAfter("abc", 'a', false)   = "ciphers"
 subAfter("abcba", 'b', false) = "cba"
 subAfter("abc", 'c', false)   = ""
 subAfter("abc", 'd', false)   = ""
      Parameters:
      text - 被查找的字符串
      separator - 分隔字符串（不包括）
      isLastSeparator - 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
      Returns:
      切割后的字符串

    • subBetween

      public static String subBetween(CharSequence text, CharSequence before, CharSequence after)
      截取指定字符串中间部分，不包括标识字符串 
       subBetween("wx[b]yz", "[", "]") = "b"
 subBetween(null, *, *)          = null
 subBetween(*, null, *)          = null
 subBetween(*, *, null)          = null
 subBetween("", "", "")          = ""
 subBetween("", "", "]")         = null
 subBetween("", "[", "]")        = null
 subBetween("yabcz", "", "")     = ""
 subBetween("yabcz", "y", "z")   = "abc"
 subBetween("yabczyabcz", "y", "z")   = "abc"
      Parameters:
      text - 被切割的字符串
      before - 截取开始的字符串标识
      after - 截取到的字符串标识
      Returns:
      截取后的字符串

    • subBetween

      public static String subBetween(CharSequence text, CharSequence beforeAndAfter)
      截取指定字符串中间部分，不包括标识字符串 
       subBetween(null, *)            = null
 subBetween("", "")             = ""
 subBetween("", "tag")          = null
 subBetween("tagabctag", null)  = null
 subBetween("tagabctag", "")    = ""
 subBetween("tagabctag", "tag") = "abc"
      Parameters:
      text - 被切割的字符串
      beforeAndAfter - 截取开始和结束的字符串标识
      Returns:
      截取后的字符串

    • subBetweenAll

      public static String[] subBetweenAll(CharSequence text, CharSequence prefix, CharSequence suffix)
      截取指定字符串多段中间部分，不包括标识字符串 
       subBetweenAll("wx[b]y[z]", "[", "]")           = ["b","z"]
 subBetweenAll(null, *, *)                              = []
 subBetweenAll(*, null, *)                              = []
 subBetweenAll(*, *, null)                              = []
 subBetweenAll("", "", "")                              = []
 subBetweenAll("", "", "]")                             = []
 subBetweenAll("", "[", "]")                            = []
 subBetweenAll("yabcz", "", "")                         = []
 subBetweenAll("yabcz", "y", "z")                       = ["abc"]
 subBetweenAll("yabczyabcz", "y", "z")                  = ["abc","abc"]
 subBetweenAll("[yabc[zy]abcz]", "[", "]");   = ["zy"]           重叠时只截取内部，
      Parameters:
      text - 被切割的字符串
      prefix - 截取开始的字符串标识
      suffix - 截取到的字符串标识
      Returns:
      截取后的字符串

    • subBetweenAll

      public static String[] subBetweenAll(CharSequence text, CharSequence prefixAndSuffix)
      截取指定字符串多段中间部分，不包括标识字符串 
       subBetweenAll(null, *)                                 = []
 subBetweenAll(*, null)                                 = []
 subBetweenAll(*, *)                            = []
 subBetweenAll("", "")                                  = []
 subBetweenAll("", "#")                                 = []
 subBetweenAll("gotanks", "")                   = []
 subBetweenAll("#gotanks#", "#")                = ["gotanks"]
 subBetweenAll("#hello# #world#!", "#")   = ["hello", "world"]
 subBetweenAll("#hello# world#!", "#");   = ["hello"]
      Parameters:
      text - 被切割的字符串
      prefixAndSuffix - 截取开始和结束的字符串标识
      Returns:
      截取后的字符串

    • repeat

      public static String repeat(char c, int count)
      重复某个字符 
       repeat('e', 0)  = ""
 repeat('e', 3)  = "eee"
 repeat('e', -2) = ""
      Parameters:
      c - 被重复的字符
      count - 重复的数目，如果小于等于0则返回""
      Returns:
      重复字符字符串

    • repeat

      public static String repeat(CharSequence text, int count)
      重复某个字符串
      Parameters:
      text - 被重复的字符
      count - 重复的数目
      Returns:
      重复字符字符串

    • repeatByLength

      public static String repeatByLength(CharSequence text, int padLen)
      重复某个字符串到指定长度
      • 如果指定长度非指定字符串的整数倍，截断到固定长度
      • 如果指定长度小于字符串本身的长度，截断之
      Parameters:
      text - 被重复的字符
      padLen - 指定长度
      Returns:
      重复字符字符串

    • repeatAndJoin

      public static String repeatAndJoin(CharSequence text, int count, CharSequence delimiter)
      重复某个字符串并通过分界符连接 
       repeatAndJoin("?", 5, ",")   = "?,?,?,?,?"
 repeatAndJoin("?", 0, ",")   = ""
 repeatAndJoin("?", 5, null) = "?????"
      Parameters:
      text - 被重复的字符串
      count - 数量
      delimiter - 分界符
      Returns:
      连接后的字符串

    • equals

      public static boolean equals(CharSequence text1, CharSequence text2)
      比较两个字符串（大小写敏感）。 
       equals(null, null)   = true
 equals(null, "abc")  = false
 equals("abc", null)  = false
 equals("abc", "abc") = true
 equals("abc", "ABC") = false
      Parameters:
      text1 - 要比较的字符串1
      text2 - 要比较的字符串2
      Returns:
      如果两个字符串相同，或者都是null，则返回true

    • equalsIgnoreCase

      public static boolean equalsIgnoreCase(CharSequence text1, CharSequence text2)
      比较两个字符串（大小写不敏感）。 
       equalsIgnoreCase(null, null)   = true
 equalsIgnoreCase(null, "abc")  = false
 equalsIgnoreCase("abc", null)  = false
 equalsIgnoreCase("abc", "abc") = true
 equalsIgnoreCase("abc", "ABC") = true
      Parameters:
      text1 - 要比较的字符串1
      text2 - 要比较的字符串2
      Returns:
      如果两个字符串相同，或者都是null，则返回true

    • equals

      public static boolean equals(CharSequence text1, CharSequence text2, boolean ignoreCase)
      比较两个字符串是否相等，规则如下
      Parameters:
      text1 - 要比较的字符串1
      text2 - 要比较的字符串2
      ignoreCase - 是否忽略大小写
      Returns:
      如果两个字符串相同，或者都是null，则返回true

    • equalsAnyIgnoreCase

      public static boolean equalsAnyIgnoreCase(CharSequence text1, CharSequence... strs)
      给定字符串是否与提供的中任意一个字符串相同（忽略大小写），相同则返回true，没有相同的返回false 如果参与比对的字符串列表为空，返回false
      Parameters:
      text1 - 给定需要检查的字符串
      strs - 需要参与比对的字符串列表
      Returns:
      是否相同

    • equalsAny

      public static boolean equalsAny(CharSequence text1, CharSequence... strs)
      给定字符串是否与提供的中任一字符串相同，相同则返回true，没有相同的返回false 如果参与比对的字符串列表为空，返回false
      Parameters:
      text1 - 给定需要检查的字符串
      strs - 需要参与比对的字符串列表
      Returns:
      是否相同

    • equalsAny

      public static boolean equalsAny(CharSequence text, boolean ignoreCase, CharSequence... args)
      给定字符串是否与提供的中任一字符串相同，相同则返回true，没有相同的返回false 如果参与比对的字符串列表为空，返回false
      Parameters:
      text - 给定需要检查的字符串
      ignoreCase - 是否忽略大小写
      args - 需要参与比对的字符串列表
      Returns:
      是否相同

    • equalsCharAt

      public static boolean equalsCharAt(CharSequence text, int position, char c)
      字符串指定位置的字符是否与给定字符相同 如果字符串为null，返回false 如果给定的位置大于字符串长度，返回false 如果给定的位置小于0，返回false
      Parameters:
      text - 字符串
      position - 位置
      c - 需要对比的字符
      Returns:
      字符串指定位置的字符是否与给定字符相同

    • isSubEquals

      public static boolean isSubEquals(CharSequence text1, int offset1, CharSequence text2, boolean ignoreCase)
      截取第一个字串的部分字符，与第二个字符串比较（长度一致），判断截取的子串是否相同 任意一个字符串为null返回false
      Parameters:
      text1 - 第一个字符串
      offset1 - 第一个字符串开始的位置
      text2 - 第二个字符串
      ignoreCase - 是否忽略大小写
      Returns:
      子串是否相同
      See Also:

    • isSubEquals

      public static boolean isSubEquals(CharSequence text1, int offset1, CharSequence text2, int offset2, int length, boolean ignoreCase)
      截取两个字符串的不同部分（长度一致），判断截取的子串是否相同 任意一个字符串为null返回false
      Parameters:
      text1 - 第一个字符串
      offset1 - 第一个字符串开始的位置
      text2 - 第二个字符串
      offset2 - 第二个字符串开始的位置
      length - 截取长度
      ignoreCase - 是否忽略大小写
      Returns:
      子串是否相同
      See Also:

    • format

      public static String format(CharSequence template, Object... params)
      格式化文本, {} 表示占位符 此方法只是简单将占位符 {} 按照顺序替换为参数 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可 例： 通常使用：format("this is {} for {}", "a", "b") = this is a for b 转义{}： format("this is \\{} for {}", "a", "b") = this is {} for a 转义\： format("this is \\\\{} for {}", "a", "b") = this is \a for b
      Parameters:
      template - 文本模板，被替换的部分用 {} 表示，如果模板为null，返回"null"
      params - 参数值
      Returns:
      格式化后的文本，如果模板为null，返回"null"

    • indexedFormat

      public static String indexedFormat(CharSequence pattern, Object... arguments)
      有序的格式化文本，使用{number}做为占位符 通常使用：format("this is {0} for {1}", "a", "b") = this is a for b
      Parameters:
      pattern - 文本格式
      arguments - 参数
      Returns:
      格式化后的文本

    • wrap

      public static String wrap(CharSequence text, CharSequence prefixAndSuffix)
      包装指定字符串 当前缀和后缀一致时使用此方法
      Parameters:
      text - 被包装的字符串
      prefixAndSuffix - 前缀和后缀
      Returns:
      包装后的字符串

    • wrap

      public static String wrap(CharSequence text, CharSequence prefix, CharSequence suffix)
      包装指定字符串
      Parameters:
      text - 被包装的字符串
      prefix - 前缀
      suffix - 后缀
      Returns:
      包装后的字符串

    • wrap

      public static String wrap(CharSequence text, char prefix, char suffix)
      包装指定字符串
      Parameters:
      text - 被包装的字符串
      prefix - 前缀
      suffix - 后缀
      Returns:
      包装后的字符串

    • wrapAllWithPair

      public static String[] wrapAllWithPair(CharSequence prefixAndSuffix, CharSequence... strs)
      使用单个字符包装多个字符串
      Parameters:
      prefixAndSuffix - 前缀和后缀
      strs - 多个字符串
      Returns:
      包装的字符串数组

    • wrapAll

      public static String[] wrapAll(CharSequence prefix, CharSequence suffix, CharSequence... strs)
      包装多个字符串
      Parameters:
      prefix - 前缀
      suffix - 后缀
      strs - 多个字符串
      Returns:
      包装的字符串数组

    • wrapIfMissing

      public static String wrapIfMissing(CharSequence text, CharSequence prefix, CharSequence suffix)
      包装指定字符串，如果前缀或后缀已经包含对应的字符串，则不再包装
      Parameters:
      text - 被包装的字符串
      prefix - 前缀
      suffix - 后缀
      Returns:
      包装后的字符串

    • wrapAllWithPairIfMissing

      public static String[] wrapAllWithPairIfMissing(CharSequence prefixAndSuffix, CharSequence... strs)
      使用成对的字符包装多个字符串，如果已经包装，则不再包装
      Parameters:
      prefixAndSuffix - 前缀和后缀
      strs - 多个字符串
      Returns:
      包装的字符串数组

    • wrapAllIfMissing

      public static String[] wrapAllIfMissing(CharSequence prefix, CharSequence suffix, CharSequence... strs)
      包装多个字符串，如果已经包装，则不再包装
      Parameters:
      prefix - 前缀
      suffix - 后缀
      strs - 多个字符串
      Returns:
      包装的字符串数组

    • unWrap

      public static String unWrap(CharSequence text, String prefix, String suffix)
      去掉字符包装，如果未被包装则返回原字符串 此方法要求prefix和suffix都存在，如果只有一个，不做去除。
      Parameters:
      text - 字符串
      prefix - 前置字符串
      suffix - 后置字符串
      Returns:
      去掉包装字符的字符串

    • unWrap

      public static String unWrap(CharSequence text, char prefix, char suffix)
      去掉字符包装，如果未被包装则返回原字符串
      Parameters:
      text - 字符串
      prefix - 前置字符
      suffix - 后置字符
      Returns:
      去掉包装字符的字符串

    • unWrap

      public static String unWrap(CharSequence text, char prefixAndSuffix)
      去掉字符包装，如果未被包装则返回原字符串
      Parameters:
      text - 字符串
      prefixAndSuffix - 前置和后置字符
      Returns:
      去掉包装字符的字符串

    • isWrap

      public static boolean isWrap(CharSequence text, CharSequence prefix, CharSequence suffix)
      指定字符串是否被包装
      Parameters:
      text - 字符串
      prefix - 前缀
      suffix - 后缀
      Returns:
      是否被包装

    • isWrap

      public static boolean isWrap(CharSequence text, String wrapper)
      指定字符串是否被同一字符包装（前后都有这些字符串）
      Parameters:
      text - 字符串
      wrapper - 包装字符串
      Returns:
      是否被包装

    • isWrap

      public static boolean isWrap(CharSequence text, char wrapper)
      指定字符串是否被同一字符包装（前后都有这些字符串）
      Parameters:
      text - 字符串
      wrapper - 包装字符
      Returns:
      是否被包装

    • isWrap

      public static boolean isWrap(CharSequence text, char prefixChar, char suffixChar)
      指定字符串是否被包装
      Parameters:
      text - 字符串
      prefixChar - 前缀
      suffixChar - 后缀
      Returns:
      是否被包装

    • left

      public static String left(String text, int len)
      获取字符串中最左边的len字符 
        left(null, *)    = null
  left(*, -ve)     = ""
  left("", *)      = ""
  left("abc", 0)   = ""
  left("abc", 2)   = "ab"
  left("abc", 4)   = "abc"
      Parameters:
      text - 要从中获取字符的字符串可能为空
      len - 所需字符串的长度
      Returns:
      最左边的字符，null如果输入为空字符串

    • right

      public static String right(String text, int len)
      获取字符串中最右边的len字符 
        right(null, *)    = null
  right(*, -ve)     = ""
  right("", *)      = ""
  right("abc", 0)   = ""
  right("abc", 2)   = "bc"
  right("abc", 4)   = "abc"
      Parameters:
      text - 要从中获取字符的字符串可能为空
      len - 所需字符串的长度
      Returns:
      最右边的字符，null如果输入为空字符串

    • mid

      public static String mid(String text, int pos, int len)
      从字符串中间获取len字符. 
        mid(null, *, *)    = null
  mid(*, *, -ve)     = ""
  mid("", 0, *)      = ""
  mid("abc", 0, 2)   = "ab"
  mid("abc", 0, 4)   = "abc"
  mid("abc", 2, 4)   = "c"
  mid("abc", 4, 2)   = ""
  mid("abc", -2, 2)  = "ab"
      Parameters:
      text - 要从中获取字符的字符串可能为空
      pos - 开始时的位置，负为零
      len - 所需字符串的长度
      Returns:
      中间的字符，null如果输入为空字符串

    • padPre

      public static String padPre(CharSequence text, int length, CharSequence padStr)
      补充字符串以满足指定长度，如果提供的字符串大于指定长度，截断之 同：leftPad (org.apache.commons.lang3.leftPad) 
       padPre(null, *, *);//null
 padPre("1", 3, "ABC");//"AB1"
 padPre("123", 2, "ABC");//"12"
 padPre("1039", -1, "0");//"103"
      Parameters:
      text - 字符串
      length - 长度
      padStr - 补充的字符
      Returns:
      补充后的字符串

    • padPre

      public static String padPre(CharSequence text, int length, char padChar)
      补充字符串以满足最小长度，如果提供的字符串大于指定长度，截断之 同：leftPad (org.apache.commons.lang3.leftPad) 
       padPre(null, *, *);//null
 padPre("1", 3, '0');//"001"
 padPre("123", 2, '0');//"12"
      Parameters:
      text - 字符串
      length - 长度
      padChar - 补充的字符
      Returns:
      补充后的字符串

    • padAfter

      public static String padAfter(CharSequence text, int length, char padChar)
      补充字符串以满足最小长度，如果提供的字符串大于指定长度，截断之 
       padAfter(null, *, *);//null
 padAfter("1", 3, '0');//"100"
 padAfter("123", 2, '0');//"23"
 padAfter("123", -1, '0')//"" 空串
      Parameters:
      text - 字符串，如果为null，直接返回null
      length - 长度
      padChar - 补充的字符
      Returns:
      补充后的字符串

    • padAfter

      public static String padAfter(CharSequence text, int length, CharSequence padStr)
      补充字符串以满足最小长度 
       padAfter(null, *, *);//null
 padAfter("1", 3, "ABC");//"1AB"
 padAfter("123", 2, "ABC");//"23"
      Parameters:
      text - 字符串，如果为null，直接返回null
      length - 长度
      padStr - 补充的字符
      Returns:
      补充后的字符串

    • center

      public static String center(CharSequence text, int size)
      居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串 
       center(null, *)   = null
 center("", 4)     = "    "
 center("ab", -1)  = "ab"
 center("ab", 4)   = " ab "
 center("abcd", 2) = "abcd"
 center("a", 4)    = " a  "
      Parameters:
      text - 字符串
      size - 指定长度
      Returns:
      补充后的字符串

    • center

      public static String center(CharSequence text, int size, char padChar)
      居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串 
       center(null, *, *)     = null
 center("", 4, ' ')     = "    "
 center("ab", -1, ' ')  = "ab"
 center("ab", 4, ' ')   = " ab "
 center("abcd", 2, ' ') = "abcd"
 center("a", 4, ' ')    = " a  "
 center("a", 4, 'y')   = "yayy"
 center("abc", 7, ' ')   = "  abc  "
      Parameters:
      text - 字符串
      size - 指定长度
      padChar - 两边补充的字符
      Returns:
      补充后的字符串

    • center

      public static String center(CharSequence text, int size, CharSequence padStr)
      居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串 
       center(null, *, *)     = null
 center("", 4, " ")     = "    "
 center("ab", -1, " ")  = "ab"
 center("ab", 4, " ")   = " ab "
 center("abcd", 2, " ") = "abcd"
 center("a", 4, " ")    = " a  "
 center("a", 4, "yz")   = "yayz"
 center("abc", 7, null) = "  abc  "
 center("abc", 7, "")   = "  abc  "
      Parameters:
      text - 字符串
      size - 指定长度
      padStr - 两边补充的字符串
      Returns:
      补充后的字符串

    • count

      public static int count(CharSequence content, CharSequence strForSearch)
      统计指定内容中包含指定字符串的数量 参数为 null 或者 "" 返回 0. 
       count(null, *)       = 0
 count("", *)         = 0
 count("abba", null)  = 0
 count("abba", "")    = 0
 count("abba", "a")   = 2
 count("abba", "ab")  = 1
 count("abba", "xxx") = 0
      Parameters:
      content - 被查找的字符串
      strForSearch - 需要查找的字符串
      Returns:
      查找到的个数

    • count

      public static int count(CharSequence content, char charForSearch)
      统计指定内容中包含指定字符的数量
      Parameters:
      content - 内容
      charForSearch - 被统计的字符
      Returns:
      包含数量

    • compare

      public static int compare(CharSequence text1, CharSequence text2, boolean nullIsLess)
      比较两个字符串，用于排序 
       compare(null, null, *)     = 0
 compare(null , "a", true)  < 0
 compare(null , "a", false) > 0
 compare("a", null, true)   > 0
 compare("a", null, false)  < 0
 compare("abc", "abc", *)   = 0
 compare("a", "b", *)       < 0
 compare("b", "a", *)       > 0
 compare("a", "B", *)       > 0
 compare("ab", "abc", *)    < 0
      Parameters:
      text1 - 字符串1
      text2 - 字符串2
      nullIsLess - null 值是否排在前（null是否小于非空值）
      Returns:
      排序值。负数：text1 < text2，正数：text1 > text2, 0：text1 == text2

    • compareIgnoreCase

      public static int compareIgnoreCase(CharSequence text1, CharSequence text2, boolean nullIsLess)
      比较两个字符串，用于排序，大小写不敏感 
       compareIgnoreCase(null, null, *)     = 0
 compareIgnoreCase(null , "a", true)  < 0
 compareIgnoreCase(null , "a", false) > 0
 compareIgnoreCase("a", null, true)   > 0
 compareIgnoreCase("a", null, false)  < 0
 compareIgnoreCase("abc", "abc", *)   = 0
 compareIgnoreCase("abc", "ABC", *)   = 0
 compareIgnoreCase("a", "b", *)       < 0
 compareIgnoreCase("b", "a", *)       > 0
 compareIgnoreCase("a", "B", *)       < 0
 compareIgnoreCase("A", "b", *)       < 0
 compareIgnoreCase("ab", "abc", *)    < 0
      Parameters:
      text1 - 字符串1
      text2 - 字符串2
      nullIsLess - null 值是否排在前（null是否小于非空值）
      Returns:
      排序值。负数：text1 < text2，正数：text1 > text2, 0：text1 == text2

    • compareVersion

      public static int compareVersion(CharSequence version1, CharSequence version2)
      比较两个版本 null版本排在最小：即： 
       compareVersion(null, "v1") < 0
 compareVersion("v1", "v1")  = 0
 compareVersion(null, null)   = 0
 compareVersion("v1", null) > 0
 compareVersion("1.0.0", "1.0.2") < 0
 compareVersion("1.0.2", "1.0.2a") < 0
 compareVersion("1.13.0", "1.12.1c") > 0
 compareVersion("V0.0.20170102", "V0.0.20170101") > 0
      Parameters:
      version1 - 版本1
      version2 - 版本2
      Returns:
      排序值。负数：version1 < version2，正数：version1 > version2, 0：version1 == version2

    • appendIfMissing

      public static String appendIfMissing(CharSequence text, CharSequence suffix, CharSequence... suffixes)
      如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串 不忽略大小写
      Parameters:
      text - 被检查的字符串
      suffix - 需要添加到结尾的字符串
      suffixes - 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
      Returns:
      如果已经结尾，返回原字符串，否则返回添加结尾的字符串

    • appendIfMissingIgnoreCase

      public static String appendIfMissingIgnoreCase(CharSequence text, CharSequence suffix, CharSequence... suffixes)
      如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串 忽略大小写
      Parameters:
      text - 被检查的字符串
      suffix - 需要添加到结尾的字符串
      suffixes - 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
      Returns:
      如果已经结尾，返回原字符串，否则返回添加结尾的字符串

    • appendIfMissing

      public static String appendIfMissing(CharSequence text, CharSequence suffix, boolean ignoreCase, CharSequence... testSuffixes)
      如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串
      Parameters:
      text - 被检查的字符串
      suffix - 需要添加到结尾的字符串，不参与检查匹配
      ignoreCase - 检查结尾时是否忽略大小写
      testSuffixes - 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
      Returns:
      如果已经结尾，返回原字符串，否则返回添加结尾的字符串

    • prependIfMissing

      public static String prependIfMissing(CharSequence text, CharSequence prefix, CharSequence... prefixes)
      如果给定字符串不是以给定的一个或多个字符串为开头，则在前面添加起始字符串 不忽略大小写
      Parameters:
      text - 被检查的字符串
      prefix - 需要添加到首部的字符串
      prefixes - 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
      Returns:
      如果已经结尾，返回原字符串，否则返回添加结尾的字符串

    • prependIfMissingIgnoreCase

      public static String prependIfMissingIgnoreCase(CharSequence text, CharSequence prefix, CharSequence... prefixes)
      如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串 忽略大小写
      Parameters:
      text - 被检查的字符串
      prefix - 需要添加到首部的字符串
      prefixes - 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
      Returns:
      如果已经结尾，返回原字符串，否则返回添加结尾的字符串

    • prependIfMissing

      public static String prependIfMissing(CharSequence text, CharSequence prefix, boolean ignoreCase, CharSequence... prefixes)
      如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串
      Parameters:
      text - 被检查的字符串
      prefix - 需要添加到首部的字符串
      ignoreCase - 检查结尾时是否忽略大小写
      prefixes - 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
      Returns:
      如果已经结尾，返回原字符串，否则返回添加结尾的字符串

    • replaceFirst

      public static String replaceFirst(CharSequence text, CharSequence searchStr, CharSequence replacedStr, boolean ignoreCase)
      替换字符串中第一个指定字符串
      Parameters:
      text - 字符串
      searchStr - 被查找的字符串
      replacedStr - 被替换的字符串
      ignoreCase - 是否忽略大小写
      Returns:
      替换后的字符串

    • replaceLast

      public static String replaceLast(CharSequence text, CharSequence searchStr, CharSequence replacedStr, boolean ignoreCase)
      替换字符串中最后一个指定字符串
      Parameters:
      text - 字符串
      searchStr - 被查找的字符串
      replacedStr - 被替换的字符串
      ignoreCase - 是否忽略大小写
      Returns:
      替换后的字符串

    • replaceIgnoreCase

      public static String replaceIgnoreCase(CharSequence text, CharSequence searchStr, CharSequence replacement)
      替换字符串中的指定字符串，忽略大小写
      Parameters:
      text - 字符串
      searchStr - 被查找的字符串
      replacement - 被替换的字符串
      Returns:
      替换后的字符串

    • replace

      public static String replace(CharSequence text, CharSequence searchStr, CharSequence replacement)
      替换字符串中的指定字符串
      Parameters:
      text - 字符串
      searchStr - 被查找的字符串
      replacement - 被替换的字符串
      Returns:
      替换后的字符串

    • replace

      public static String replace(CharSequence text, CharSequence searchStr, CharSequence replacement, boolean ignoreCase)
      替换字符串中的指定字符串
      Parameters:
      text - 字符串
      searchStr - 被查找的字符串
      replacement - 被替换的字符串
      ignoreCase - 是否忽略大小写
      Returns:
      替换后的字符串

    • replace

      public static String replace(CharSequence text, int fromIndex, CharSequence searchStr, CharSequence replacement, boolean ignoreCase)
      替换字符串中的指定字符串 如果指定字符串出现多次，则全部替换
      Parameters:
      text - 字符串
      fromIndex - 开始位置（包括）
      searchStr - 被查找的字符串
      replacement - 被替换的字符串
      ignoreCase - 是否忽略大小写
      Returns:
      替换后的字符串

    • replaceByCodePoint

      public static String replaceByCodePoint(CharSequence text, int beginInclude, int endExclude, char replacedChar)
      替换指定字符串的指定区间内字符为固定字符，替换后字符串长度不变 如替换的区间长度为10，则替换后的字符重复10次 此方法使用String.codePoints()完成拆分替换
      Parameters:
      text - 字符串
      beginInclude - 开始位置（包含）
      endExclude - 结束位置（不包含）
      replacedChar - 被替换的字符
      Returns:
      替换后的字符串

    • replaceByCodePoint

      public static String replaceByCodePoint(CharSequence text, int beginInclude, int endExclude, CharSequence replacedStr)
      替换指定字符串的指定区间内字符为指定字符串，字符串只重复一次 此方法使用String.codePoints()完成拆分替换
      Parameters:
      text - 字符串
      beginInclude - 开始位置（包含）
      endExclude - 结束位置（不包含）
      replacedStr - 被替换的字符串
      Returns:
      替换后的字符串

    • replace

      public static String replace(CharSequence text, Pattern pattern, FunctionX<Matcher,String> replaceFun)
      替换所有正则匹配的文本，并使用自定义函数决定如何替换 replaceFun可以提取出匹配到的内容的不同部分，然后经过重新处理、组装变成新的内容放回原位。 
       replace(this.content, "(\\d+)", parameters -> "-" + parameters.group(1) + "-")
 // 结果为："ZZZaaabbbccc中文-1234-"
      Parameters:
      text - 要替换的字符串
      pattern - 用于匹配的正则式
      replaceFun - 决定如何替换的函数
      Returns:
      替换后的字符串
      See Also:

    • replace

      public static String replace(CharSequence text, String regex, FunctionX<Matcher,String> replaceFun)
      替换所有正则匹配的文本，并使用自定义函数决定如何替换
      Parameters:
      text - 要替换的字符串
      regex - 用于匹配的正则式
      replaceFun - 决定如何替换的函数
      Returns:
      替换后的字符串
      See Also:

    • hide

      public static String hide(CharSequence text, int startInclude, int endExclude)
      替换指定字符串的指定区间内字符为"*" 
       hide(null,*,*)=null
 hide("",0,*)=""
 hide("jackduan@163.com",-1,4)   ****duan@163.com
 hide("jackduan@163.com",2,3)    ja*kduan@163.com
 hide("jackduan@163.com",3,2)    jackduan@163.com
 hide("jackduan@163.com",16,16)  jackduan@163.com
 hide("jackduan@163.com",16,17)  jackduan@163.com
      Parameters:
      text - 字符串
      startInclude - 开始位置（包含）
      endExclude - 结束位置（不包含）
      Returns:
      替换后的字符串

    • replaceChars

      public static String replaceChars(CharSequence text, String chars, CharSequence replacedStr)
      替换字符字符数组中所有的字符为replacedStr 提供的chars为所有需要被替换的字符，例如："\r\n"，则"\r"和"\n"都会被替换，哪怕他们单独存在
      Parameters:
      text - 被检查的字符串
      chars - 需要替换的字符列表，用一个字符串表示这个字符列表
      replacedStr - 替换成的字符串
      Returns:
      新字符串

    • replaceChars

      public static String replaceChars(CharSequence text, char[] chars, CharSequence replacedStr)
      替换字符字符数组中所有的字符为replacedStr
      Parameters:
      text - 被检查的字符串
      chars - 需要替换的字符列表
      replacedStr - 替换成的字符串
      Returns:
      新字符串

    • replaceAt

      public static String replaceAt(CharSequence text, int index, UnaryOperator<Character> operator)
      按照给定逻辑替换指定位置的字符，如字符大小写转换等
      Parameters:
      text - 字符串
      index - 位置，-1表示最后一个字符
      operator - 替换逻辑，给定原字符，返回新字符
      Returns:
      替换后的字符串

    • length

      public static int length(CharSequence cs)
      获取字符串的长度，如果为null返回0
      Parameters:
      cs - a 字符串
      Returns:
      字符串的长度，如果为null返回0

    • codeLength

      public static int codeLength(CharSequence cs)
      获取字符串的Unicode字符长度，如果为null返回0 Unicode字符长度指实际Unicode字符个数，如emoji算一个字符
      Parameters:
      cs - a 字符串
      Returns:
      字符串的长度，如果为null返回0

    • byteLength

      public static int byteLength(CharSequence cs, Charset charset)
      给定字符串转为bytes后的byte数（byte长度）
      Parameters:
      cs - 字符串
      charset - 编码
      Returns:
      byte长度

    • totalLength

      public static int totalLength(CharSequence... args)
      给定字符串数组的总长度 null字符长度定义为0
      Parameters:
      args - 字符串数组
      Returns:
      总长度

    • limitLength

      public static String limitLength(CharSequence text, int length)
      限制字符串长度，如果超过指定长度，截取指定长度并在末尾加"..."
      Parameters:
      text - 字符串
      length - 最大长度
      Returns:
      切割后的剩余的前半部分字符串+"..."

    • limitByteLengthUtf8

      public static String limitByteLengthUtf8(CharSequence text, int maxBytesLength, boolean appendDots)
      截断字符串，使用UTF8编码为字节后不超过maxBytes长度
      Parameters:
      text - 原始字符串
      maxBytesLength - 最大字节数
      appendDots - 截断后是否追加省略号(...)
      Returns:
      限制后的长度

    • limitByteLength

      public static String limitByteLength(CharSequence text, Charset charset, int maxBytesLength, int factor, boolean appendDots)
      截断字符串，使用其按照指定编码为字节后不超过maxBytes长度 此方法用于截取总bytes数不超过指定长度，如果字符出没有超出原样输出，如果超出了，则截取掉超出部分，并可选添加...， 但是添加“...”后总长度也不超过限制长度。
      Parameters:
      text - 原始字符串
      charset - 指定编码
      maxBytesLength - 最大字节数
      factor - 速算因子，取该编码下单个字符的最大可能字节数
      appendDots - 截断后是否追加省略号(...)
      Returns:
      限制后的长度

    • firstNonNull

      public static <T extends CharSequence> T firstNonNull(T... args)
      返回第一个非null 元素
      Type Parameters:
      T - 元素类型
      Parameters:
      args - 多个元素
      Returns:
      第一个非空元素，如果给定的数组为空或者都为空，返回null

    • firstNonEmpty

      public static <T extends CharSequence> T firstNonEmpty(T... args)
      返回第一个非empty 元素
      Type Parameters:
      T - 元素类型
      Parameters:
      args - 多个元素
      Returns:
      第一个非空元素，如果给定的数组为空或者都为空，返回null
      See Also:

    • firstNonBlank

      public static <T extends CharSequence> T firstNonBlank(T... args)
      返回第一个非blank 元素
      Type Parameters:
      T - 元素类型
      Parameters:
      args - 多个元素
      Returns:
      第一个非空元素，如果给定的数组为空或者都为空，返回null
      See Also:

    • upperFirstAndAddPre

      public static String upperFirstAndAddPre(CharSequence text, String preString)
      原字符串首字母大写并在其首部添加指定字符串 例如：text=name, preString=get = return getName
      Parameters:
      text - 被处理的字符串
      preString - 添加的首部
      Returns:
      处理后的字符串

    • upperFirst

      public static String upperFirst(CharSequence text)
      大写首字母 例如：text = name, return Name
      Parameters:
      text - 字符串
      Returns:
      字符串

    • upperAt

      public static String upperAt(CharSequence text, int index)
      大写对应下标字母 
       例如: text = name,index = 1, return nAme
      Parameters:
      text - 字符串
      index - 下标，支持负数，-1表示最后一个字符
      Returns:
      字符串

    • lowerFirst

      public static String lowerFirst(CharSequence text)
      小写首字母 例如：text = Name, return name
      Parameters:
      text - 字符串
      Returns:
      字符串

    • lowerAt

      public static String lowerAt(CharSequence text, int index)
      小写对应下标字母 例如: text = NAME,index = 1, return NaME
      Parameters:
      text - 字符串
      index - 下标，支持负数，-1表示最后一个字符
      Returns:
      字符串

    • filter

      public static String filter(CharSequence text, Predicate<Character> predicate)
      过滤字符串
      Parameters:
      text - 字符串
      predicate - 过滤器，Predicate.test(Object)为true保留字符
      Returns:
      过滤后的字符串

    • isUpperCase

      public static boolean isUpperCase(CharSequence text)
      给定字符串中的字母是否全部为大写，判断依据如下： 
       1. 大写字母包括A-Z
 2. 其它非字母的Unicode符都算作大写
      Parameters:
      text - 被检查的字符串
      Returns:
      是否全部为大写

    • isLowerCase

      public static boolean isLowerCase(CharSequence text)
      给定字符串中的字母是否全部为小写，判断依据如下： 
       1. 小写字母包括a-z
 2. 其它非字母的Unicode符都算作小写
      Parameters:
      text - 被检查的字符串
      Returns:
      是否全部为小写

    • swapCase

      public static String swapCase(String text)
      切换给定字符串中的大小写。大写转小写，小写转大写。 
       swapCase(null)                 = null
 swapCase("")                   = ""
 swapCase("The dog has a BONE") = "tHE DOG HAS A bone"
      Parameters:
      text - 字符串
      Returns:
      交换后的字符串

    • toUnderlineCase

      public static String toUnderlineCase(CharSequence text)
      将驼峰式命名的字符串转换为下划线方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。 例如： 
       HelloWorld = hello_world
 Hello_World = hello_world
 HelloWorld_test = hello_world_test
      Parameters:
      text - 转换前的驼峰式命名的字符串，也可以为下划线形式
      Returns:
      转换后下划线方式命名的字符串
      See Also:

    • toSymbolCase

      public static String toSymbolCase(CharSequence text, char symbol)
      将驼峰式命名的字符串转换为使用符号连接方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。
      Parameters:
      text - 转换前的驼峰式命名的字符串，也可以为符号连接形式
      symbol - 连接符
      Returns:
      转换后符号连接方式命名的字符串
      See Also:

    • toCamelCase

      public static String toCamelCase(CharSequence name)
      将下划线方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：hello_world = helloWorld
      Parameters:
      name - 转换前的下划线大写方式命名的字符串
      Returns:
      转换后的驼峰式命名的字符串
      See Also:

    • toCamelCase

      public static String toCamelCase(CharSequence name, char symbol)
      将连接符方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：hello_world = helloWorld; hello-world = helloWorld
      Parameters:
      name - 转换前的下划线大写方式命名的字符串
      symbol - 连接符
      Returns:
      转换后的驼峰式命名的字符串
      See Also:

    • builder

      public static StringBuilder builder(CharSequence text)
      创建StringBuilder对象 如果对象本身为StringBuilder，直接返回，否则新建
      Parameters:
      text - CharSequence
      Returns:
      StringBuilder对象

    • builder

      public static StringBuilder builder(CharSequence... args)
      创建StringBuilder对象
      Parameters:
      args - 初始字符串列表
      Returns:
      StringBuilder对象

    • getGeneralField

      public static String getGeneralField(CharSequence getOrSetMethodName)
      获得set或get或is方法对应的标准属性名 例如：setName 返回 name 
       getName = name
 setName = name
 isName  = name
      Parameters:
      getOrSetMethodName - Get或Set方法名
      Returns:
      如果是set或get方法名，返回field， 否则null

    • genSetter

      public static String genSetter(CharSequence fieldName)
      生成set方法名 例如：name 返回 setName
      Parameters:
      fieldName - 属性名
      Returns:
      setXxx

    • genGetter

      public static String genGetter(CharSequence fieldName)
      生成get方法名
      Parameters:
      fieldName - 属性名
      Returns:
      getXxx

    • concat

      public static String concat(boolean isNullToEmpty, CharSequence... args)
      连接多个字符串为一个
      Parameters:
      isNullToEmpty - 是否null转为""
      args - 字符串数组
      Returns:
      连接后的字符串

    • brief

      public static String brief(CharSequence text, int maxLength)
      将给定字符串，变成 "xxx...xxx" 形式的字符串
      • abcdefgh 9 - abcdefgh
      • abcdefgh 8 - abcdefgh
      • abcdefgh 7 - ab...gh
      • abcdefgh 6 - ab...h
      • abcdefgh 5 - a...h
      • abcdefgh 4 - a..h
      • abcdefgh 3 - a.h
      • abcdefgh 2 - a.
      • abcdefgh 1 - a
      • abcdefgh 0 - abcdefgh
      • abcdefgh -1 - abcdefgh
      Parameters:
      text - 字符串
      maxLength - 结果的最大长度
      Returns:
      截取后的字符串

    • join

      public static String join(CharSequence conjunction, Object... objs)
      以 conjunction 为分隔符将多个对象转换为字符串
      Parameters:
      conjunction - 分隔符 Symbol.COMMA
      objs - 数组
      Returns:
      连接后的字符串
      See Also:

    • join

      public static <T> String join(CharSequence conjunction, Iterable<T> iterable)
      以 conjunction 为分隔符将多个对象转换为字符串
      Type Parameters:
      T - 元素类型
      Parameters:
      conjunction - 分隔符 Symbol.COMMA
      iterable - 集合
      Returns:
      连接后的字符串
      See Also:

    • isNumeric

      public static boolean isNumeric(CharSequence text)
      检查字符串是否都为数字组成
      Parameters:
      text - 字符串
      Returns:
      是否都为数字组成

    • move

      public static String move(CharSequence text, int startInclude, int endExclude, int moveLength)
      循环位移指定位置的字符串为指定距离 当moveLength大于0向右位移，小于0向左位移，0不位移 当moveLength大于字符串长度时采取循环位移策略，即位移到头后从头（尾）位移，例如长度为10，位移13则表示位移3
      Parameters:
      text - 字符串
      startInclude - 起始位置（包括）
      endExclude - 结束位置（不包括）
      moveLength - 移动距离，负数表示左移，正数为右移
      Returns:
      位移后的字符串

    • isCharEquals

      public static boolean isCharEquals(CharSequence text)
      检查给定字符串的所有字符是否都一样
      Parameters:
      text - 字符出啊
      Returns:
      给定字符串的所有字符是否都一样

    • normalize

      public static String normalize(CharSequence text)
      对字符串归一化处理，如 "Á" 可以使用 "u00C1"或 "u0041u0301"表示，实际测试中两个字符串并不equals 因此使用此方法归一为一种表示形式，默认按照W3C通常建议的，在NFC中交换文本。
      Parameters:
      text - 归一化的字符串
      Returns:
      归一化后的字符串
      See Also:

    • fixLength

      public static String fixLength(CharSequence text, char fixedChar, int length)
      在给定字符串末尾填充指定字符，以达到给定长度 如果字符串本身的长度大于等于length，返回原字符串
      Parameters:
      text - 字符串
      fixedChar - 补充的字符
      length - 补充到的长度
      Returns:
      补充后的字符串

    • commonPrefix

      public static CharSequence commonPrefix(CharSequence text1, CharSequence text2)
      获取两个字符串的公共前缀 
      
 commonPrefix("abb", "acc") // "a"
      Parameters:
      text1 - 字符串1
      text2 - 字符串2
      Returns:
      字符串1和字符串2的公共前缀

    • commonSuffix

      public static CharSequence commonSuffix(CharSequence text1, CharSequence text2)
      获取两个字符串的公共后缀 
      
 commonSuffix("aba", "cba") // "ba"
      Parameters:
      text1 - 字符串1
      text2 - 字符串2
      Returns:
      字符串1和字符串2的公共后缀

    • splitTo

      public static <T> T splitTo(CharSequence text, CharSequence separator, Class<T> resultType)
      切分字符串，去除切分后每个元素两边的空白符，去除空白项，并转为结果类型
      Type Parameters:
      T - 结果类型
      Parameters:
      text - 被切分的字符串
      separator - 分隔符字符
      resultType - 结果类型的类，可以是数组或集合
      Returns:
      long数组

    • splitTrim

      public static List<String> splitTrim(CharSequence text, CharSequence separator)
      切分字符串，去除切分后每个元素两边的空白符，去除空白项
      Parameters:
      text - 被切分的字符串
      separator - 分隔符字符
      Returns:
      切分后的集合

    • splitToArray

      public static String[] splitToArray(CharSequence text, CharSequence separator)
      切分字符串，如果分隔符不存在则返回原字符串 此方法不会去除切分字符串后每个元素两边的空格，不忽略空串
      Parameters:
      text - 被切分的字符串
      separator - 分隔符
      Returns:
      字符串

    • split

      public static String split(String text)
      切分字符串
      Parameters:
      text - 被切分的字符串
      Returns:
      字符串

    • split

      public static String split(String text, String separator, String reserve)
      切分字符串
      Parameters:
      text - 被切分的字符串
      separator - 分隔符
      reserve - 替换后的分隔符
      Returns:
      字符串

    • split

      public static List<String> split(CharSequence text, CharSequence separator)
      切分字符串，如果分隔符不存在则返回原字符串 此方法不会去除切分字符串后每个元素两边的空格，不忽略空串
      Parameters:
      text - 被切分的字符串
      separator - 分隔符
      Returns:
      字符串

    • split

      public static List<String> split(CharSequence text, CharSequence separator, boolean isTrim, boolean ignoreEmpty)
      切分字符串，不忽略大小写
      Parameters:
      text - 被切分的字符串
      separator - 分隔符字符串
      isTrim - 是否去除切分字符串后每个元素两边的空格
      ignoreEmpty - 是否忽略空串
      Returns:
      切分后的集合

    • split

      public static List<String> split(CharSequence text, CharSequence separator, int limit, boolean isTrim, boolean ignoreEmpty)
      切分字符串，不忽略大小写
      Parameters:
      text - 被切分的字符串
      separator - 分隔符字符串
      limit - 限制分片数，小于等于0表示无限制
      isTrim - 是否去除切分字符串后每个元素两边的空格
      ignoreEmpty - 是否忽略空串
      Returns:
      切分后的集合

    • split

      public static List<String> split(CharSequence text, CharSequence separator, int limit, boolean isTrim, boolean ignoreEmpty, boolean ignoreCase)
      切分字符串 如果提供的字符串为null，则返回一个空的ArrayList 如果提供的字符串为""，则当ignoreEmpty时返回空的ArrayList，否则返回只有一个""元素的ArrayList
      Parameters:
      text - 被切分的字符串
      separator - 分隔符字符串
      limit - 限制分片数，小于等于0表示无限制
      isTrim - 是否去除切分字符串后每个元素两边的空格
      ignoreEmpty - 是否忽略空串
      ignoreCase - 是否忽略大小写
      Returns:
      切分后的集合

    • split

      public static <R> List<R> split(CharSequence text, CharSequence separator, int limit, boolean ignoreEmpty, boolean ignoreCase, Function<String,R> mapping)
      切分字符串 如果提供的字符串为null，则返回一个空的ArrayList 如果提供的字符串为""，则当ignoreEmpty时返回空的ArrayList，否则返回只有一个""元素的ArrayList
      Type Parameters:
      R - 元素类型
      Parameters:
      text - 被切分的字符串
      separator - 分隔符字符串
      limit - 限制分片数，小于等于0表示无限制
      ignoreEmpty - 是否忽略空串
      ignoreCase - 是否忽略大小写
      mapping - 切分后字段映射函数
      Returns:
      切分后的集合

    • splitPath

      public static List<String> splitPath(CharSequence text)
      切分路径字符串 如果为空字符串或者null 则返回空集合 空路径会被忽略
      Parameters:
      text - 被切分的字符串
      Returns:
      切分后的集合

    • splitPath

      public static List<String> splitPath(CharSequence text, int limit)
      切分路径字符串 如果为空字符串或者null 则返回空集合 空路径会被忽略
      Parameters:
      text - 被切分的字符串
      limit - 限制分片数，小于等于0表示无限制
      Returns:
      切分后的集合

    • splitByBlank

      public static List<String> splitByBlank(CharSequence text)
      使用空白符切分字符串 切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一 如果为空字符串或者null 则返回空集合
      Parameters:
      text - 被切分的字符串
      Returns:
      切分后的集合

    • splitByBlank

      public static List<String> splitByBlank(CharSequence text, int limit)
      使用空白符切分字符串 切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一 如果为空字符串或者null 则返回空集合
      Parameters:
      text - 被切分的字符串
      limit - 限制分片数，小于等于0表示无限制
      Returns:
      切分后的集合

    • splitByBlankToArray

      public static String[] splitByBlankToArray(CharSequence text, int limit)
      切分字符串为字符串数组
      Parameters:
      text - 被切分的字符串
      limit - 限制分片数，小于等于0表示无限制
      Returns:
      切分后的集合

    • splitByRegex

      public static List<String> splitByRegex(CharSequence text, String separatorRegex, int limit, boolean isTrim, boolean ignoreEmpty)
      通过正则切分字符串，规则如下：
      • 当提供的str为null时，返回new ArrayList(0)
      • 当提供的str为""时，返回[""]
      • 当提供的separatorRegex为empty(null or "")时，返回[text]，即只有原串一个元素的数组
      Parameters:
      text - 字符串
      separatorRegex - 分隔符正则
      limit - 限制分片数，小于等于0表示无限制
      isTrim - 是否去除切分字符串后每个元素两边的空格
      ignoreEmpty - 是否忽略空串
      Returns:
      切分后的集合

    • splitByRegex

      public static List<String> splitByRegex(CharSequence text, Pattern separatorPattern, int limit, boolean isTrim, boolean ignoreEmpty)
      通过正则切分字符串，规则如下：
      • 当提供的str为null时，返回new ArrayList(0)
      • 当提供的str为""时，返回[""]
      • 当提供的separatorRegex为empty(null or "")时，返回[text]，即只有原串一个元素的数组
      Parameters:
      text - 字符串
      separatorPattern - 分隔符正则Pattern
      limit - 限制分片数，小于等于0表示无限制
      isTrim - 是否去除切分字符串后每个元素两边的空格
      ignoreEmpty - 是否忽略空串
      Returns:
      切分后的集合

    • splitByRegexToArray

      public static String[] splitByRegexToArray(CharSequence text, Pattern separatorPattern, int limit, boolean isTrim, boolean ignoreEmpty)
      通过正则切分字符串为字符串数组
      Parameters:
      text - 被切分的字符串
      separatorPattern - 分隔符正则Pattern
      limit - 限制分片数，小于等于0表示无限制
      isTrim - 是否去除切分字符串后每个元素两边的空格
      ignoreEmpty - 是否忽略空串
      Returns:
      切分后的集合

    • splitByLength

      public static String[] splitByLength(CharSequence text, int len)
      根据给定长度，将给定字符串截取为多个部分
      Parameters:
      text - 字符串
      len - 每一个小节的长度，必须大于0
      Returns:
      截取后的字符串数组

    • trimFunc

      public static Function<String,String> trimFunc(boolean isTrim)
      Trim函数
      Parameters:
      isTrim - 是否trim
      Returns:
      Function

    • toChars

      public static int[] toChars(CharSequence text, boolean isCodePoint)
      将字符串转换为字符数组
      Parameters:
      text - 字符串
      isCodePoint - 是否为Unicode码点（即支持emoji等多char字符）
      Returns:
      字符数组