StringHelper (template-utils-lang 2.7.0.RELEASE API)

java.lang.Object
- org.templateproject.lang.text.StringHelper

```
public class StringHelper
extends Object
```
字符串工具类,hutool来源剔除其他关联类,使得此类尽量可以单独使用,不受其他类限制剔除了某些不常用的方法,挪移某些方法至更恰当的类中,更易辨析作用修改以适应template-xxx系列项目规范

从以下版本开始:

1.0

作者:

xiaoleilu

字段概要

字段
限定符和类型	字段和说明
`static String`	`BACKSLASH`
`static char`	`C_BACKSLASH`
`static char`	`C_COLON`
`static char`	`C_COMMA`
`static char`	`C_CR`
`static char`	`C_DELIMITER_END`
`static char`	`C_DELIMITER_START`
`static char`	`C_DOT`
`static char`	`C_LF`
`static char`	`C_SLASH`
`static char`	`C_SPACE`
`static char`	`C_TAB`
`static char`	`C_UNDERLINE`
`static String`	`COLON`
`static String`	`COMMA`
`static String`	`CR`
`static String`	`CRLF`
`static String`	`DELEMITER_START`
`static String`	`DELIMITER_END`
`static String`	`DOT`
`static String`	`DOUBLE_DOT`
`static String`	`EMPTY`
`static String`	`EMPTY_JSON`
`static String`	`HTML_AMP`
`static String`	`HTML_GT`
`static String`	`HTML_LT`
`static String`	`HTML_NBSP`
`static String`	`HTML_QUOTE`
`static String`	`LF`
`static String`	`SLASH`
`static String`	`SPACE`
`static String`	`TAB`
`static String`	`UNDERLINE`

构造器概要

构造器
构造器和说明

StringHelper()

构造器
构造器和说明
`StringHelper()`

方法概要

方法
限定符和类型	方法和说明
`String`	`addPrefixIfNot(String str, String prefix)` 如果给定字符串不是以prefix开头的，在开头补充 prefix
`String`	`addSuffixIfNot(String str, String suffix)` 如果给定字符串不是以suffix结尾的，在尾部补充 suffix
`StringBuilder`	`builder()` 创建StringBuilder对象
`StringBuilder`	`builder(int capacity)` 创建StringBuilder对象
`StringBuilder`	`builder(String... strs)` 创建StringBuilder对象
`ByteBuffer`	`byteBuffer(String str, String charset)` 字符串转换为byteBuffer
`byte[]`	`bytes(String str)` 编码字符串使用系统默认编码
`byte[]`	`bytes(String str, Charset charset)` 编码字符串
`byte[]`	`bytes(String str, String charset)` 编码字符串
`String`	`cleanBlank(String str)` 清理空白字符
`boolean`	`containsIgnoreCase(String str, String testStr)` 是否包含特定字符，忽略大小写，如果给定两个参数都为`null`，返回true
`int`	`count(String content, char charForSearch)` 统计指定内容中包含指定字符的数量
`int`	`count(String content, String strForSearch)` 统计指定内容中包含指定字符串的数量参数为 `null` 或者 "" 返回 `0`.
`String`	`emptyToNull(String str)` 当给定字符串为空字符串时，转换为`null`
`boolean`	`endWith(String str, String suffix, boolean isIgnoreCase)` 是否以指定字符串结尾
`boolean`	`endWithIgnoreCase(String str, String suffix)` 是否以指定字符串结尾，忽略大小写
`boolean`	`equals(String str1, String str2)` 比较两个字符串（大小写敏感）。
`boolean`	`equalsIgnoreCase(String str1, String str2)` 比较两个字符串（大小写不敏感）。
`String`	`format(String template, Map<?,?> map)` 格式化文本，使用 {varName} 占位 map = {a: "aValue", b: "bValue"} format("{a} and {b}", map) ----> aValue and bValue
`String`	`format(String 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
`StringReader`	`getReader(String str)` 获得StringReader
`StringWriter`	`getWriter()` 获得StringWriter
`boolean`	`hasBlank(CharSequence... strs)` 是否包含空字符串
`boolean`	`hasEmpty(CharSequence... strs)` 是否包含空字符串
`String`	`indexedFormat(String pattern, Object... arguments)` 有序的格式化文本，使用{number}做为占位符例：通常使用：format("this is {0} for {1}", "a", "b") -> this is a for b
`boolean`	`isAllBlank(CharSequence... strs)` 给定所有字符串是否为空白
`boolean`	`isAllEmpty(CharSequence... strs)` 是否全部为空字符串
`boolean`	`isBlank(CharSequence str)` 字符串是否为空白空白的定义如下： 1、为null 2、为不可见字符（如空格） 3、""
`boolean`	`isEmpty(CharSequence str)` 字符串是否为空，空的定义如下 1、为null 2、为""
`boolean`	`isNotBlank(CharSequence str)` 字符串是否为非空白空白的定义如下： 1、不为null 2、不为不可见字符（如空格） 3、不为""
`boolean`	`isNotEmpty(CharSequence str)` 字符串是否为非空白空白的定义如下： 1、不为null 2、不为""
`boolean`	`isSurround(CharSequence str, char prefix, char suffix)` 给定字符串是否被字符包围
`boolean`	`isSurround(String str, String prefix, String suffix)` 给定字符串是否被字符包围
`boolean`	`isWrap(String str, char wrapper)` 指定字符串是否被同一字符包装（前后都有这些字符串）
`boolean`	`isWrap(String str, char prefixChar, char suffixChar)` 指定字符串是否被包装
`boolean`	`isWrap(String str, String wrapper)` 指定字符串是否被同一字符包装（前后都有这些字符串）
`boolean`	`isWrap(String str, String prefix, String suffix)` 指定字符串是否被包装
`String`	`lowerFIrstLetter(String str)` 小写首字母例如：str = Name, return name
`String`	`nullToDefault(String str, String defaultStr)` 如果字符串是`null`，则返回指定默认字符串，否则返回字符串本身。
`String`	`nullToEmpty(String str)` 当给定字符串为null时，转换为Empty
`String`	`padEnd(String str, int minLength, char padChar)` 补充字符串以满足最小长度 StringHelper.padEnd("1", 3, '0');//"100"
`String`	`padPre(String str, int minLength, char padChar)` 补充字符串以满足最小长度 StringHelper.padPre("1", 3, '0');//"001"
`String`	`removeAll(String str, CharSequence strToRemove)` 移除字符串中所有给定字符串例：removeAll("aa-bb-cc-dd", "-") -> aabbccdd
`String`	`removePreAndLowerFirst(String str, int preLength)` 去掉首部指定长度的字符串并将剩余字符串首字母小写例如：str=setName, preLength=3 -> return name
`String`	`removePreAndLowerFirst(String str, String prefix)` 去掉首部指定长度的字符串并将剩余字符串首字母小写例如：str=setName, prefix=set -> return name
`String`	`removePrefix(String str, String prefix)` 去掉指定前缀
`String`	`removePrefixIgnoreCase(String str, String prefix)` 忽略大小写去掉指定前缀
`String`	`removeSufAndLowerFirst(String str, String suffix)` 去掉指定后缀，并小写首字母
`String`	`removeSuffix(String str, String suffix)` 去掉指定后缀
`String`	`removeSuffixIgnoreCase(String str, String suffix)` 忽略大小写去掉指定后缀
`String`	`repeat(char c, int count)` 重复某个字符
`String`	`repeat(String str, int count)` 重复某个字符串
`List<String>`	`split(String str, char separator)` 切分字符串 a#b#c -> [a,b,c] a##b#c -> [a,"",b,c]
`List<String>`	`split(String str, char separator, int limit)` 切分字符串
`String[]`	`split(String str, int len)` 根据给定长度，将给定字符串截取为多个部分
`String[]`	`split(String str, String delimiter)` 切分字符串 from jodd
`String[]`	`splitToArray(String str, char separator)` 切分字符串
`String[]`	`splitToArray(String str, char separator, int limit)` 切分字符串
`boolean`	`startWith(String str, String prefix, boolean isIgnoreCase)` 是否以指定字符串开头
`boolean`	`startWithIgnoreCase(String str, String prefix)` 是否以指定字符串开头，忽略大小写
`String`	`str(byte[] data, Charset charset)` 解码字节码
`String`	`str(Byte[] data, Charset charset)` 解码字节码
`String`	`str(byte[] bytes, String charset)` 将byte数组转为字符串
`String`	`str(Byte[] bytes, String charset)` 将Byte数组转为字符串
`String`	`str(ByteBuffer data, Charset charset)` 将编码的byteBuffer数据转换为字符串
`String`	`str(ByteBuffer data, String charset)` 将编码的byteBuffer数据转换为字符串
`String`	`str(Object obj, Charset charset)` 将对象转为字符串 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
`String`	`str(Object obj, String charsetName)` 将对象转为字符串 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
`String`	`sub(String string, int fromIndex, int toIndex)` 改进JDK subString index从0开始计算，最后一个字符为-1 如果from和to位置一样，返回 "" 如果from或to为负数，则按照length从后向前数位置，如果绝对值大于字符串长度，则from归到0，to归到length 如果经过修正的index中from大于to，则互换from和to example: abcdefgh 2 3 -> c abcdefgh 2 -3 -> cde
`String`	`subPre(String string, int toIndex)` 切割前部分
`String`	`subSuf(String string, int fromIndex)` 切割后部分
`String`	`toCamelCase(String name)` 将下划线方式命名的字符串转换为驼峰式。
`String`	`toUnderlineCase(String camelCaseStr)` 将驼峰式命名的字符串转换为下划线方式。
`String`	`trim(String str)` 除去字符串头尾部的空白，如果字符串是`null`，依然返回`null`。
`void`	`trim(String[] strs)` 给定字符串数组全部做去首尾空格
`String`	`trim(String str, int mode)` 除去字符串头尾部的空白符，如果字符串是`null`，依然返回`null`。
`String`	`trimEnd(String str)` 除去字符串尾部的空白，如果字符串是`null`，则返回`null`。
`String`	`trimStart(String str)` 除去字符串头部的空白，如果字符串是`null`，则返回`null`。
`String`	`upperFirstLetter(String str)` 大写首字母例如：str = name, return Name
`String`	`upperFirstLetterAndAddPre(String str, String preString)` 原字符串首字母大写并在其首部添加指定字符串例如：str=name, preString=get -> return getName
`byte[]`	`utf8Bytes(String str)` 编码字符串，编码为UTF-8
`String`	`utf8Str(Object obj)` 将对象转为字符串 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细资料
  - C_SPACE
```
public static final char C_SPACE
```
    另请参阅:
    常量字段值
  - C_TAB
```
public static final char C_TAB
```
    另请参阅:
    常量字段值
  - C_DOT
```
public static final char C_DOT
```
    另请参阅:
    常量字段值
  - C_SLASH
```
public static final char C_SLASH
```
    另请参阅:
    常量字段值
  - C_BACKSLASH
```
public static final char C_BACKSLASH
```
    另请参阅:
    常量字段值
  - C_CR
```
public static final char C_CR
```
    另请参阅:
    常量字段值
  - C_LF
```
public static final char C_LF
```
    另请参阅:
    常量字段值
  - C_UNDERLINE
```
public static final char C_UNDERLINE
```
    另请参阅:
    常量字段值
  - C_COMMA
```
public static final char C_COMMA
```
    另请参阅:
    常量字段值
  - C_DELIMITER_START
```
public static final char C_DELIMITER_START
```
    另请参阅:
    常量字段值
  - C_DELIMITER_END
```
public static final char C_DELIMITER_END
```
    另请参阅:
    常量字段值
  - C_COLON
```
public static final char C_COLON
```
    另请参阅:
    常量字段值
  - SPACE
```
public static final String SPACE
```
    另请参阅:
    常量字段值
  - TAB
```
public static final String TAB
```
    另请参阅:
    常量字段值
  - DOT
```
public static final String DOT
```
    另请参阅:
    常量字段值
  - DOUBLE_DOT
```
public static final String DOUBLE_DOT
```
    另请参阅:
    常量字段值
  - SLASH
```
public static final String SLASH
```
    另请参阅:
    常量字段值
  - BACKSLASH
```
public static final String BACKSLASH
```
    另请参阅:
    常量字段值
  - EMPTY
```
public static final String EMPTY
```
    另请参阅:
    常量字段值
  - CR
```
public static final String CR
```
    另请参阅:
    常量字段值
  - LF
```
public static final String LF
```
    另请参阅:
    常量字段值
  - CRLF
```
public static final String CRLF
```
    另请参阅:
    常量字段值
  - UNDERLINE
```
public static final String UNDERLINE
```
    另请参阅:
    常量字段值
  - COMMA
```
public static final String COMMA
```
    另请参阅:
    常量字段值
  - DELEMITER_START
```
public static final String DELEMITER_START
```
    另请参阅:
    常量字段值
  - DELIMITER_END
```
public static final String DELIMITER_END
```
    另请参阅:
    常量字段值
  - COLON
```
public static final String COLON
```
    另请参阅:
    常量字段值
  - HTML_NBSP
```
public static final String HTML_NBSP
```
    另请参阅:
    常量字段值
  - HTML_AMP
```
public static final String HTML_AMP
```
    另请参阅:
    常量字段值
  - HTML_QUOTE
```
public static final String HTML_QUOTE
```
    另请参阅:
    常量字段值
  - HTML_LT
```
public static final String HTML_LT
```
    另请参阅:
    常量字段值
  - HTML_GT
```
public static final String HTML_GT
```
    另请参阅:
    常量字段值
  - EMPTY_JSON
```
public static final String EMPTY_JSON
```
    另请参阅:
    常量字段值
- 构造器详细资料
  - StringHelper
```
public StringHelper()
```
- 方法详细资料
  - isBlank
```
public boolean isBlank(CharSequence str)
```
    字符串是否为空白空白的定义如下：
    1、为null
    2、为不可见字符（如空格）
    3、""
    
    参数:
    str - 被检测的字符串
    
    返回:
    是否为空
  - isNotBlank
```
public boolean isNotBlank(CharSequence str)
```
    字符串是否为非空白空白的定义如下：
    1、不为null
    2、不为不可见字符（如空格）
    3、不为""
    
    参数:
    str - 被检测的字符串
    
    返回:
    是否为非空
  - hasBlank
```
public boolean hasBlank(CharSequence... strs)
```
    是否包含空字符串
    
    参数:
    strs - 字符串列表
    
    返回:
    是否包含空字符串
  - isAllBlank
```
public boolean isAllBlank(CharSequence... strs)
```
    给定所有字符串是否为空白
    
    参数:
    strs - 字符串
    
    返回:
    所有字符串是否为空白
  - isEmpty
```
public boolean isEmpty(CharSequence str)
```
    字符串是否为空，空的定义如下 1、为null
    2、为""
    
    参数:
    str - 被检测的字符串
    
    返回:
    是否为空
  - isNotEmpty
```
public boolean isNotEmpty(CharSequence str)
```
    字符串是否为非空白空白的定义如下：
    1、不为null
    2、不为""
    
    参数:
    str - 被检测的字符串
    
    返回:
    是否为非空
  - nullToEmpty
```
public String nullToEmpty(String str)
```
    当给定字符串为null时，转换为Empty
    
    参数:
    str - 被转换的字符串
    
    返回:
    转换后的字符串
  - nullToDefault
```
public String nullToDefault(String str,
                   String defaultStr)
```
    如果字符串是null，则返回指定默认字符串，否则返回字符串本身。
```
 nullToDefault(null, "default")  = "default"
 nullToDefault("", "default")    = ""
 nullToDefault("  ", "default")  = "  "
 nullToDefault("bat", "default") = "bat"
 
```
    参数:
    str - 要转换的字符串
    defaultStr - 默认字符串
    
    返回:
    字符串本身或指定的默认字符串
  - emptyToNull
```
public String emptyToNull(String str)
```
    当给定字符串为空字符串时，转换为null
    
    参数:
    str - 被转换的字符串
    
    返回:
    转换后的字符串
  - hasEmpty
```
public boolean hasEmpty(CharSequence... strs)
```
    是否包含空字符串
    
    参数:
    strs - 字符串列表
    
    返回:
    是否包含空字符串
  - isAllEmpty
```
public boolean isAllEmpty(CharSequence... strs)
```
    是否全部为空字符串
    
    参数:
    strs - 字符串列表
    
    返回:
    是否全部为空字符串
  - trim
```
public String trim(String str)
```
    除去字符串头尾部的空白，如果字符串是null，依然返回null。
    
    注意，和String.trim不同，此方法使用Character.isWhitespace 来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。
```
 trim(null)          = null
 trim("")            = ""
 trim("     ")       = ""
 trim("abc")         = "abc"
 trim("    abc    ") = "abc"
 
```
    参数:
    str - 要处理的字符串
    
    返回:
    除去空白的字符串，如果原字串为null，则返回null
  - trim
```
public void trim(String[] strs)
```
    给定字符串数组全部做去首尾空格
    
    参数:
    strs - 字符串数组
  - trimStart
```
public String trimStart(String str)
```
    除去字符串头部的空白，如果字符串是null，则返回null。
    注意，和String.trim不同，此方法使用Character.isWhitespace 来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。
```
 trimStart(null)         = null
 trimStart("")           = ""
 trimStart("abc")        = "abc"
 trimStart("  abc")      = "abc"
 trimStart("abc  ")      = "abc  "
 trimStart(" abc ")      = "abc "
 
```
    参数:
    str - 要处理的字符串
    
    返回:
    除去空白的字符串，如果原字串为null或结果字符串为""，则返回 null
  - trimEnd
```
public String trimEnd(String str)
```
    除去字符串尾部的空白，如果字符串是null，则返回null。
    注意，和String.trim不同，此方法使用Character.isWhitespace 来判定空白，因而可以除去英文字符集之外的其它空白，如中文空格。
```
 trimEnd(null)       = null
 trimEnd("")         = ""
 trimEnd("abc")      = "abc"
 trimEnd("  abc")    = "  abc"
 trimEnd("abc  ")    = "abc"
 trimEnd(" abc ")    = " abc"
 
```
    参数:
    str - 要处理的字符串
    
    返回:
    除去空白的字符串，如果原字串为null或结果字符串为""，则返回 null
  - trim
```
public String trim(String str,
          int mode)
```
    除去字符串头尾部的空白符，如果字符串是null，依然返回null。
    
    参数:
    str - 要处理的字符串
    mode - -1表示trimStart，0表示trim全部， 1表示trimEnd
    
    返回:
    除去指定字符后的的字符串，如果原字串为null，则返回null
  - startWith
```
public boolean startWith(String str,
                String prefix,
                boolean isIgnoreCase)
```
    是否以指定字符串开头
    
    参数:
    str - 被监测字符串
    prefix - 开头字符串
    isIgnoreCase - 是否忽略大小写
    
    返回:
    是否以指定字符串开头
  - startWithIgnoreCase
```
public boolean startWithIgnoreCase(String str,
                          String prefix)
```
    是否以指定字符串开头，忽略大小写
    
    参数:
    str - 被监测字符串
    prefix - 开头字符串
    
    返回:
    是否以指定字符串开头
  - endWith
```
public boolean endWith(String str,
              String suffix,
              boolean isIgnoreCase)
```
    是否以指定字符串结尾
    
    参数:
    str - 被监测字符串
    suffix - 结尾字符串
    isIgnoreCase - 是否忽略大小写
    
    返回:
    是否以指定字符串结尾
  - endWithIgnoreCase
```
public boolean endWithIgnoreCase(String str,
                        String suffix)
```
    是否以指定字符串结尾，忽略大小写
    
    参数:
    str - 被监测字符串
    suffix - 结尾字符串
    
    返回:
    是否以指定字符串结尾
  - containsIgnoreCase
```
public boolean containsIgnoreCase(String str,
                         String testStr)
```
    是否包含特定字符，忽略大小写，如果给定两个参数都为null，返回true
    
    参数:
    str - 被检测字符串
    testStr - 被测试是否包含的字符串
    
    返回:
    是否包含
  - removeAll
```
public String removeAll(String str,
               CharSequence strToRemove)
```
    移除字符串中所有给定字符串
    例：removeAll("aa-bb-cc-dd", "-") -> aabbccdd
    
    参数:
    str - 字符串
    strToRemove - 被移除的字符串
    
    返回:
    移除后的字符串
  - removePreAndLowerFirst
```
public String removePreAndLowerFirst(String str,
                            int preLength)
```
    去掉首部指定长度的字符串并将剩余字符串首字母小写
    例如：str=setName, preLength=3 -> return name
    
    参数:
    str - 被处理的字符串
    preLength - 去掉的长度
    
    返回:
    处理后的字符串，不符合规范返回null
  - removePreAndLowerFirst
```
public String removePreAndLowerFirst(String str,
                            String prefix)
```
    去掉首部指定长度的字符串并将剩余字符串首字母小写
    例如：str=setName, prefix=set -> return name
    
    参数:
    str - 被处理的字符串
    prefix - 前缀
    
    返回:
    处理后的字符串，不符合规范返回null
  - upperFirstLetterAndAddPre
```
public String upperFirstLetterAndAddPre(String str,
                               String preString)
```
    原字符串首字母大写并在其首部添加指定字符串例如：str=name, preString=get -> return getName
    
    参数:
    str - 被处理的字符串
    preString - 添加的首部
    
    返回:
    处理后的字符串
  - upperFirstLetter
```
public String upperFirstLetter(String str)
```
    大写首字母
    例如：str = name, return Name
    
    参数:
    str - 字符串
    
    返回:
    字符串
  - lowerFIrstLetter
```
public String lowerFIrstLetter(String str)
```
    小写首字母
    例如：str = Name, return name
    
    参数:
    str - 字符串
    
    返回:
    字符串
  - removePrefix
```
public String removePrefix(String str,
                  String prefix)
```
    去掉指定前缀
    
    参数:
    str - 字符串
    prefix - 前缀
    
    返回:
    切掉后的字符串，若前缀不是 preffix，返回原字符串
  - removePrefixIgnoreCase
```
public String removePrefixIgnoreCase(String str,
                            String prefix)
```
    忽略大小写去掉指定前缀
    
    参数:
    str - 字符串
    prefix - 前缀
    
    返回:
    切掉后的字符串，若前缀不是 prefix，返回原字符串
  - removeSuffix
```
public String removeSuffix(String str,
                  String suffix)
```
    去掉指定后缀
    
    参数:
    str - 字符串
    suffix - 后缀
    
    返回:
    切掉后的字符串，若后缀不是 suffix，返回原字符串
  - removeSufAndLowerFirst
```
public String removeSufAndLowerFirst(String str,
                            String suffix)
```
    去掉指定后缀，并小写首字母
    
    参数:
    str - 字符串
    suffix - 后缀
    
    返回:
    切掉后的字符串，若后缀不是 suffix，返回原字符串
  - removeSuffixIgnoreCase
```
public String removeSuffixIgnoreCase(String str,
                            String suffix)
```
    忽略大小写去掉指定后缀
    
    参数:
    str - 字符串
    suffix - 后缀
    
    返回:
    切掉后的字符串，若后缀不是 suffix，返回原字符串
  - addPrefixIfNot
```
public String addPrefixIfNot(String str,
                    String prefix)
```
    如果给定字符串不是以prefix开头的，在开头补充 prefix
    
    参数:
    str - 字符串
    prefix - 前缀
    
    返回:
    补充后的字符串
  - addSuffixIfNot
```
public String addSuffixIfNot(String str,
                    String suffix)
```
    如果给定字符串不是以suffix结尾的，在尾部补充 suffix
    
    参数:
    str - 字符串
    suffix - 后缀
    
    返回:
    补充后的字符串
  - cleanBlank
```
public String cleanBlank(String str)
```
    清理空白字符
    
    参数:
    str - 被清理的字符串
    
    返回:
    清理后的字符串
  - splitToArray
```
public String[] splitToArray(String str,
                    char separator)
```
    切分字符串
    
    参数:
    str - 被切分的字符串
    separator - 分隔符字符
    
    返回:
    切分后的集合
  - split
```
public List<String> split(String str,
                 char separator)
```
    切分字符串
    a#b#c -> [a,b,c]
    a##b#c -> [a,"",b,c]
    
    参数:
    str - 被切分的字符串
    separator - 分隔符字符
    
    返回:
    切分后的集合
  - splitToArray
```
public String[] splitToArray(String str,
                    char separator,
                    int limit)
```
    切分字符串
    
    参数:
    str - 被切分的字符串
    separator - 分隔符字符
    limit - 限制分片数
    
    返回:
    切分后的集合
  - split
```
public List<String> split(String str,
                 char separator,
                 int limit)
```
    切分字符串
    
    参数:
    str - 被切分的字符串
    separator - 分隔符字符
    limit - 限制分片数
    
    返回:
    切分后的集合
  - split
```
public String[] split(String str,
             String delimiter)
```
    切分字符串
    from jodd
    
    参数:
    str - 被切分的字符串
    delimiter - 分隔符
    
    返回:
    字符串
  - split
```
public String[] split(String str,
             int len)
```
    根据给定长度，将给定字符串截取为多个部分
    
    参数:
    str - 字符串
    len - 每一个小节的长度
    
    返回:
    截取后的字符串数组
  - sub
```
public String sub(String string,
         int fromIndex,
         int toIndex)
```
    改进JDK subString
    index从0开始计算，最后一个字符为-1
    如果from和to位置一样，返回 ""
    如果from或to为负数，则按照length从后向前数位置，如果绝对值大于字符串长度，则from归到0，to归到length
    如果经过修正的index中from大于to，则互换from和to example:
    abcdefgh 2 3 -> c
    abcdefgh 2 -3 -> cde
    
    参数:
    string - String
    fromIndex - 开始的index（包括）
    toIndex - 结束的index（不包括）
    
    返回:
    字串
  - subPre
```
public String subPre(String string,
            int toIndex)
```
    切割前部分
    
    参数:
    string - 字符串
    toIndex - 切割到的位置（不包括）
    
    返回:
    切割后的字符串
  - subSuf
```
public String subSuf(String string,
            int fromIndex)
```
    切割后部分
    
    参数:
    string - 字符串
    fromIndex - 切割开始的位置（包括）
    
    返回:
    切割后的字符串
  - isSurround
```
public boolean isSurround(String str,
                 String prefix,
                 String suffix)
```
    给定字符串是否被字符包围
    
    参数:
    str - 字符串
    prefix - 前缀
    suffix - 后缀
    
    返回:
    是否包围，空串不包围
  - isSurround
```
public boolean isSurround(CharSequence str,
                 char prefix,
                 char suffix)
```
    给定字符串是否被字符包围
    
    参数:
    str - 字符串
    prefix - 前缀
    suffix - 后缀
    
    返回:
    是否包围，空串不包围
  - repeat
```
public String repeat(char c,
            int count)
```
    重复某个字符
    
    参数:
    c - 被重复的字符
    count - 重复的数目
    
    返回:
    重复字符字符串
  - repeat
```
public String repeat(String str,
            int count)
```
    重复某个字符串
    
    参数:
    str - 被重复的字符
    count - 重复的数目
    
    返回:
    重复字符字符串
  - equals
```
public boolean equals(String str1,
             String str2)
```
    比较两个字符串（大小写敏感）。
```
 equals(null, null)   = true
 equals(null, "abc")  = false
 equals("abc", null)  = false
 equals("abc", "abc") = true
 equals("abc", "ABC") = false
 
```
    参数:
    str1 - 要比较的字符串1
    str2 - 要比较的字符串2
    
    返回:
    如果两个字符串相同，或者都是null，则返回true
  - equalsIgnoreCase
```
public boolean equalsIgnoreCase(String str1,
                       String str2)
```
    比较两个字符串（大小写不敏感）。
```
 equalsIgnoreCase(null, null)   = true
 equalsIgnoreCase(null, "abc")  = false
 equalsIgnoreCase("abc", null)  = false
 equalsIgnoreCase("abc", "abc") = true
 equalsIgnoreCase("abc", "ABC") = true
 
```
    参数:
    str1 - 要比较的字符串1
    str2 - 要比较的字符串2
    
    返回:
    如果两个字符串相同，或者都是null，则返回true
  - indexedFormat
```
public String indexedFormat(String pattern,
                   Object... arguments)
```
    有序的格式化文本，使用{number}做为占位符
    例：
    通常使用：format("this is {0} for {1}", "a", "b") -> this is a for b
    
    参数:
    pattern - 文本格式
    arguments - 参数
    
    返回:
    格式化后的文本
  - format
```
public String format(String 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
    
    参数:
    template - 文本模板，被替换的部分用 {} 表示
    params - 参数值
    
    返回:
    格式化后的文本
  - format
```
public String format(String template,
            Map<?,?> map)
```
    格式化文本，使用 {varName} 占位
    map = {a: "aValue", b: "bValue"} format("{a} and {b}", map) ----> aValue and bValue
    
    参数:
    template - 文本模板，被替换的部分用 {key} 表示
    map - 参数值对
    
    返回:
    格式化后的文本
  - utf8Bytes
```
public byte[] utf8Bytes(String str)
```
    编码字符串，编码为UTF-8
    
    参数:
    str - 字符串
    
    返回:
    编码后的字节码
  - bytes
```
public byte[] bytes(String str)
```
    编码字符串
    使用系统默认编码
    
    参数:
    str - 字符串
    
    返回:
    编码后的字节码
  - bytes
```
public byte[] bytes(String str,
           String charset)
```
    编码字符串
    
    参数:
    str - 字符串
    charset - 字符集，如果此字段为空，则解码的结果取决于平台
    
    返回:
    编码后的字节码
  - bytes
```
public byte[] bytes(String str,
           Charset charset)
```
    编码字符串
    
    参数:
    str - 字符串
    charset - 字符集，如果此字段为空，则解码的结果取决于平台
    
    返回:
    编码后的字节码
  - utf8Str
```
public String utf8Str(Object obj)
```
    将对象转为字符串
    1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
    
    参数:
    obj - 对象
    
    返回:
    字符串
  - str
```
public String str(Object obj,
         String charsetName)
```
    将对象转为字符串
    1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
    
    参数:
    obj - 对象
    charsetName - 字符集
    
    返回:
    字符串
  - str
```
public String str(Object obj,
         Charset charset)
```
    将对象转为字符串
    1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
    
    参数:
    obj - 对象
    charset - 字符集
    
    返回:
    字符串
  - str
```
public String str(byte[] bytes,
         String charset)
```
    将byte数组转为字符串
    
    参数:
    bytes - byte数组
    charset - 字符集
    
    返回:
    字符串
  - str
```
public String str(byte[] data,
         Charset charset)
```
    解码字节码
    
    参数:
    data - 字符串
    charset - 字符集，如果此字段为空，则解码的结果取决于平台
    
    返回:
    解码后的字符串
  - str
```
public String str(Byte[] bytes,
         String charset)
```
    将Byte数组转为字符串
    
    参数:
    bytes - byte数组
    charset - 字符集
    
    返回:
    字符串
  - str
```
public String str(Byte[] data,
         Charset charset)
```
    解码字节码
    
    参数:
    data - 字符串
    charset - 字符集，如果此字段为空，则解码的结果取决于平台
    
    返回:
    解码后的字符串
  - str
```
public String str(ByteBuffer data,
         String charset)
```
    将编码的byteBuffer数据转换为字符串
    
    参数:
    data - 数据
    charset - 字符集，如果为空使用当前系统字符集
    
    返回:
    字符串
  - str
```
public String str(ByteBuffer data,
         Charset charset)
```
    将编码的byteBuffer数据转换为字符串
    
    参数:
    data - 数据
    charset - 字符集，如果为空使用当前系统字符集
    
    返回:
    字符串
  - byteBuffer
```
public ByteBuffer byteBuffer(String str,
                    String charset)
```
    字符串转换为byteBuffer
    
    参数:
    str - 字符串
    charset - 编码
    
    返回:
    byteBuffer
  - toUnderlineCase
```
public String toUnderlineCase(String camelCaseStr)
```
    将驼峰式命名的字符串转换为下划线方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。
    例如：HelloWorld->hello_world
    
    参数:
    camelCaseStr - 转换前的驼峰式命名的字符串
    
    返回:
    转换后下划线大写方式命名的字符串
  - toCamelCase
```
public String toCamelCase(String name)
```
    将下划线方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。
    例如：hello_world->HelloWorld
    
    参数:
    name - 转换前的下划线大写方式命名的字符串
    
    返回:
    转换后的驼峰式命名的字符串
  - isWrap
```
public boolean isWrap(String str,
             String prefix,
             String suffix)
```
    指定字符串是否被包装
    
    参数:
    str - 字符串
    prefix - 前缀
    suffix - 后缀
    
    返回:
    是否被包装
  - isWrap
```
public boolean isWrap(String str,
             String wrapper)
```
    指定字符串是否被同一字符包装（前后都有这些字符串）
    
    参数:
    str - 字符串
    wrapper - 包装字符串
    
    返回:
    是否被包装
  - isWrap
```
public boolean isWrap(String str,
             char wrapper)
```
    指定字符串是否被同一字符包装（前后都有这些字符串）
    
    参数:
    str - 字符串
    wrapper - 包装字符
    
    返回:
    是否被包装
  - isWrap
```
public boolean isWrap(String str,
             char prefixChar,
             char suffixChar)
```
    指定字符串是否被包装
    
    参数:
    str - 字符串
    prefixChar - 前缀
    suffixChar - 后缀
    
    返回:
    是否被包装
  - padPre
```
public String padPre(String str,
            int minLength,
            char padChar)
```
    补充字符串以满足最小长度 StringHelper.padPre("1", 3, '0');//"001"
    
    参数:
    str - 字符串
    minLength - 最小长度
    padChar - 补充的字符
    
    返回:
    补充后的字符串
  - padEnd
```
public String padEnd(String str,
            int minLength,
            char padChar)
```
    补充字符串以满足最小长度 StringHelper.padEnd("1", 3, '0');//"100"
    
    参数:
    str - 字符串
    minLength - 最小长度
    padChar - 补充的字符
    
    返回:
    补充后的字符串
  - builder
```
public StringBuilder builder()
```
    创建StringBuilder对象
    
    返回:
    StringBuilder对象
  - builder
```
public StringBuilder builder(int capacity)
```
    创建StringBuilder对象
    
    返回:
    StringBuilder对象
  - builder
```
public StringBuilder builder(String... strs)
```
    创建StringBuilder对象
    
    返回:
    StringBuilder对象
  - getReader
```
public StringReader getReader(String str)
```
    获得StringReader
    
    参数:
    str - 字符串
    
    返回:
    StringReader
  - getWriter
```
public StringWriter getWriter()
```
    获得StringWriter
    
    返回:
    StringWriter
  - count
```
public int count(String content,
        String strForSearch)
```
    统计指定内容中包含指定字符串的数量
    参数为 null 或者 "" 返回 0.
```
 StringHelper.count(null, *)       = 0
 StringHelper.count("", *)         = 0
 StringHelper.count("abba", null)  = 0
 StringHelper.count("abba", "")    = 0
 StringHelper.count("abba", "a")   = 2
 StringHelper.count("abba", "ab")  = 1
 StringHelper.count("abba", "xxx") = 0
 
```
    参数:
    content - 被查找的字符串
    strForSearch - 需要查找的字符串
    
    返回:
    查找到的个数
  - count
```
public int count(String content,
        char charForSearch)
```
    统计指定内容中包含指定字符的数量
    
    参数:
    content - 内容
    charForSearch - 被统计的字符
    
    返回:
    包含数量

类 StringHelper

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

C_SPACE

C_TAB

C_DOT

C_SLASH

C_BACKSLASH

C_CR

C_LF

C_UNDERLINE

C_COMMA

C_DELIMITER_START

C_DELIMITER_END

C_COLON

SPACE

TAB

DOT

DOUBLE_DOT

SLASH

BACKSLASH

EMPTY

CR

LF

CRLF

UNDERLINE

COMMA

DELEMITER_START

DELIMITER_END

COLON

HTML_NBSP

HTML_AMP

HTML_QUOTE

HTML_LT

HTML_GT

EMPTY_JSON

构造器详细资料

StringHelper

方法详细资料

isBlank

isNotBlank

hasBlank

isAllBlank

isEmpty

isNotEmpty

nullToEmpty

nullToDefault

emptyToNull

hasEmpty

isAllEmpty

trim

trim

trimStart

trimEnd

trim

startWith

startWithIgnoreCase

endWith

endWithIgnoreCase

containsIgnoreCase

removeAll

removePreAndLowerFirst

removePreAndLowerFirst

upperFirstLetterAndAddPre

upperFirstLetter

lowerFIrstLetter

removePrefix

removePrefixIgnoreCase

removeSuffix

removeSufAndLowerFirst

removeSuffixIgnoreCase

addPrefixIfNot

addSuffixIfNot

cleanBlank

splitToArray

split

splitToArray