StrUtil (hutool 2.16.2 API)

java.lang.Object
- com.xiaoleilu.hutool.util.StrUtil

```
public class StrUtil
extends Object
```
字符串工具类

作者:

xiaoleilu

字段概要

字段
限定符和类型	字段和说明
`static String`	`BACKSLASH`
`static char`	`C_BACKSLASH`
`static char`	`C_COLON`
`static char`	`C_COMMA`
`static char`	`C_CR`
`static char`	`C_DELIM_END`
`static char`	`C_DELIM_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`	`DELIM_END`
`static String`	`DELIM_START`
`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`

构造器概要

构造器
构造器和说明

StrUtil()

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

方法概要

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

从类继承的方法 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_DELIM_START
```
public static final char C_DELIM_START
```
    另请参阅:
    常量字段值
  - C_DELIM_END
```
public static final char C_DELIM_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
```
    另请参阅:
    常量字段值
  - DELIM_START
```
public static final String DELIM_START
```
    另请参阅:
    常量字段值
  - DELIM_END
```
public static final String DELIM_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
```
    另请参阅:
    常量字段值
- 构造器详细资料
  - StrUtil
```
public StrUtil()
```
- 方法详细资料
  - isBlank
```
public static boolean isBlank(CharSequence str)
```
    字符串是否为空白空白的定义如下：
    1、为null
    2、为不可见字符（如空格）
    3、""
    
    参数:
    str - 被检测的字符串
    
    返回:
    是否为空
  - isNotBlank
```
public static boolean isNotBlank(CharSequence str)
```
    字符串是否为非空白空白的定义如下：
    1、不为null
    2、不为不可见字符（如空格）
    3、不为""
    
    参数:
    str - 被检测的字符串
    
    返回:
    是否为非空
  - hasBlank
```
public static boolean hasBlank(CharSequence... strs)
```
    是否包含空字符串
    
    参数:
    strs - 字符串列表
    
    返回:
    是否包含空字符串
  - isAllBlank
```
public static boolean isAllBlank(CharSequence... strs)
```
    给定所有字符串是否为空白
    
    参数:
    strs - 字符串
    
    返回:
    所有字符串是否为空白
  - isEmpty
```
public static boolean isEmpty(CharSequence str)
```
    字符串是否为空，空的定义如下 1、为null
    2、为""
    
    参数:
    str - 被检测的字符串
    
    返回:
    是否为空
  - isNotEmpty
```
public static boolean isNotEmpty(CharSequence str)
```
    字符串是否为非空白空白的定义如下：
    1、不为null
    2、不为""
    
    参数:
    str - 被检测的字符串
    
    返回:
    是否为非空
  - nullToEmpty
```
public static String nullToEmpty(String str)
```
    当给定字符串为null时，转换为Empty
    
    参数:
    str - 被转换的字符串
    
    返回:
    转换后的字符串
  - nullToDefault
```
public static String nullToDefault(String str,
                   String defaultStr)
```
    如果字符串是null，则返回指定默认字符串，否则返回字符串本身。
```
 nullToDefault(null, "default")  = "default"
 nullToDefault("", "default")    = ""
 nullToDefault("  ", "default")  = "  "
 nullToDefault("bat", "default") = "bat"
 
```
    参数:
    str - 要转换的字符串
    defaultStr - 默认字符串
    
    返回:
    字符串本身或指定的默认字符串
  - emptyToNull
```
public static String emptyToNull(String str)
```
    当给定字符串为空字符串时，转换为null
    
    参数:
    str - 被转换的字符串
    
    返回:
    转换后的字符串
  - hasEmpty
```
public static boolean hasEmpty(CharSequence... strs)
```
    是否包含空字符串
    
    参数:
    strs - 字符串列表
    
    返回:
    是否包含空字符串
  - isAllEmpty
```
public static boolean isAllEmpty(CharSequence... strs)
```
    是否全部为空字符串
    
    参数:
    strs - 字符串列表
    
    返回:
    是否全部为空字符串
  - trim
```
public static 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 static void trim(String[] strs)
```
    给定字符串数组全部做去首尾空格
    
    参数:
    strs - 字符串数组
  - trimStart
```
public static 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 static 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 static String trim(String str,
          int mode)
```
    除去字符串头尾部的空白符，如果字符串是null，依然返回null。
    
    参数:
    str - 要处理的字符串
    mode - -1表示trimStart，0表示trim全部， 1表示trimEnd
    
    返回:
    除去指定字符后的的字符串，如果原字串为null，则返回null
  - startWith
```
public static boolean startWith(String str,
                String prefix,
                boolean isIgnoreCase)
```
    是否以指定字符串开头
    
    参数:
    str - 被监测字符串
    prefix - 开头字符串
    isIgnoreCase - 是否忽略大小写
    
    返回:
    是否以指定字符串开头
  - startWithIgnoreCase
```
public static boolean startWithIgnoreCase(String str,
                          String prefix)
```
    是否以指定字符串开头，忽略大小写
    
    参数:
    str - 被监测字符串
    prefix - 开头字符串
    
    返回:
    是否以指定字符串开头
  - endWith
```
public static boolean endWith(String str,
              String suffix,
              boolean isIgnoreCase)
```
    是否以指定字符串结尾
    
    参数:
    str - 被监测字符串
    suffix - 结尾字符串
    isIgnoreCase - 是否忽略大小写
    
    返回:
    是否以指定字符串结尾
  - endWithIgnoreCase
```
public static boolean endWithIgnoreCase(String str,
                        String suffix)
```
    是否以指定字符串结尾，忽略大小写
    
    参数:
    str - 被监测字符串
    suffix - 结尾字符串
    
    返回:
    是否以指定字符串结尾
  - containsIgnoreCase
```
public static boolean containsIgnoreCase(String str,
                         String testStr)
```
    是否包含特定字符，忽略大小写，如果给定两个参数都为null，返回true
    
    参数:
    str - 被检测字符串
    testStr - 被测试是否包含的字符串
    
    返回:
    是否包含
  - getGeneralField
```
public static String getGeneralField(String getOrSetMethodName)
```
    获得set或get方法对应的标准属性名
    例如：setName 返回 name
    
    参数:
    getOrSetMethodName -
    
    返回:
    如果是set或get方法名，返回field，否则null
  - genSetter
```
public static String genSetter(String fieldName)
```
    生成set方法名
    例如：name 返回 setName
    
    参数:
    fieldName - 属性名
    
    返回:
    setXxx
  - genGetter
```
public static String genGetter(String fieldName)
```
    生成get方法名
    
    参数:
    fieldName - 属性名
    
    返回:
    getXxx
  - removeAll
```
public static String removeAll(String str,
               CharSequence strToRemove)
```
    移除字符串中所有给定字符串
    例：removeAll("aa-bb-cc-dd", "-") -> aabbccdd
    
    参数:
    str - 字符串
    strToRemove - 被移除的字符串
    
    返回:
    移除后的字符串
  - removePreAndLowerFirst
```
public static String removePreAndLowerFirst(String str,
                            int preLength)
```
    去掉首部指定长度的字符串并将剩余字符串首字母小写
    例如：str=setName, preLength=3 -> return name
    
    参数:
    str - 被处理的字符串
    preLength - 去掉的长度
    
    返回:
    处理后的字符串，不符合规范返回null
  - removePreAndLowerFirst
```
public static String removePreAndLowerFirst(String str,
                            String prefix)
```
    去掉首部指定长度的字符串并将剩余字符串首字母小写
    例如：str=setName, prefix=set -> return name
    
    参数:
    str - 被处理的字符串
    prefix - 前缀
    
    返回:
    处理后的字符串，不符合规范返回null
  - upperFirstAndAddPre
```
public static String upperFirstAndAddPre(String str,
                         String preString)
```
    原字符串首字母大写并在其首部添加指定字符串例如：str=name, preString=get -> return getName
    
    参数:
    str - 被处理的字符串
    preString - 添加的首部
    
    返回:
    处理后的字符串
  - upperFirst
```
public static String upperFirst(String str)
```
    大写首字母
    例如：str = name, return Name
    
    参数:
    str - 字符串
    
    返回:
    字符串
  - lowerFirst
```
public static String lowerFirst(String str)
```
    小写首字母
    例如：str = Name, return name
    
    参数:
    str - 字符串
    
    返回:
    字符串
  - removePrefix
```
public static String removePrefix(String str,
                  String prefix)
```
    去掉指定前缀
    
    参数:
    str - 字符串
    prefix - 前缀
    
    返回:
    切掉后的字符串，若前缀不是 preffix，返回原字符串
  - removePrefixIgnoreCase
```
public static String removePrefixIgnoreCase(String str,
                            String prefix)
```
    忽略大小写去掉指定前缀
    
    参数:
    str - 字符串
    prefix - 前缀
    
    返回:
    切掉后的字符串，若前缀不是 prefix，返回原字符串
  - removeSuffix
```
public static String removeSuffix(String str,
                  String suffix)
```
    去掉指定后缀
    
    参数:
    str - 字符串
    suffix - 后缀
    
    返回:
    切掉后的字符串，若后缀不是 suffix，返回原字符串
  - removeSufAndLowerFirst
```
public static String removeSufAndLowerFirst(String str,
                            String suffix)
```
    去掉指定后缀，并小写首字母
    
    参数:
    str - 字符串
    suffix - 后缀
    
    返回:
    切掉后的字符串，若后缀不是 suffix，返回原字符串
  - removeSuffixIgnoreCase
```
public static String removeSuffixIgnoreCase(String str,
                            String suffix)
```
    忽略大小写去掉指定后缀
    
    参数:
    str - 字符串
    suffix - 后缀
    
    返回:
    切掉后的字符串，若后缀不是 suffix，返回原字符串
  - addPrefixIfNot
```
public static String addPrefixIfNot(String str,
                    String prefix)
```
    如果给定字符串不是以prefix开头的，在开头补充 prefix
    
    参数:
    str - 字符串
    prefix - 前缀
    
    返回:
    补充后的字符串
  - addSuffixIfNot
```
public static String addSuffixIfNot(String str,
                    String suffix)
```
    如果给定字符串不是以suffix结尾的，在尾部补充 suffix
    
    参数:
    str - 字符串
    suffix - 后缀
    
    返回:
    补充后的字符串
  - cleanBlank
```
public static String cleanBlank(String str)
```
    清理空白字符
    
    参数:
    str - 被清理的字符串
    
    返回:
    清理后的字符串
  - splitToArray
```
public static String[] splitToArray(String str,
                    char separator)
```
    切分字符串
    
    参数:
    str - 被切分的字符串
    separator - 分隔符字符
    
    返回:
    切分后的集合
  - split
```
public static List<String> split(String str,
                 char separator)
```
    切分字符串
    a#b#c -> [a,b,c]
    a##b#c -> [a,"",b,c]
    
    参数:
    str - 被切分的字符串
    separator - 分隔符字符
    
    返回:
    切分后的集合
  - splitToArray
```
public static String[] splitToArray(String str,
                    char separator,
                    int limit)
```
    切分字符串
    
    参数:
    str - 被切分的字符串
    separator - 分隔符字符
    limit - 限制分片数
    
    返回:
    切分后的集合
  - split
```
public static List<String> split(String str,
                 char separator,
                 int limit)
```
    切分字符串
    
    参数:
    str - 被切分的字符串
    separator - 分隔符字符
    limit - 限制分片数
    
    返回:
    切分后的集合
  - split
```
public static String[] split(String str,
             String delimiter)
```
    切分字符串
    from jodd
    
    参数:
    str - 被切分的字符串
    delimiter - 分隔符
    
    返回:
    字符串
  - split
```
public static String[] split(String str,
             int len)
```
    根据给定长度，将给定字符串截取为多个部分
    
    参数:
    str - 字符串
    len - 每一个小节的长度
    
    返回:
    截取后的字符串数组
  - sub
```
public static 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 static String subPre(String string,
            int toIndex)
```
    切割前部分
    
    参数:
    string - 字符串
    toIndex - 切割到的位置（不包括）
    
    返回:
    切割后的字符串
  - subSuf
```
public static String subSuf(String string,
            int fromIndex)
```
    切割后部分
    
    参数:
    string - 字符串
    fromIndex - 切割开始的位置（包括）
    
    返回:
    切割后的字符串
  - isSurround
```
public static boolean isSurround(String str,
                 String prefix,
                 String suffix)
```
    给定字符串是否被字符包围
    
    参数:
    str - 字符串
    prefix - 前缀
    suffix - 后缀
    
    返回:
    是否包围，空串不包围
  - isSurround
```
public static boolean isSurround(CharSequence str,
                 char prefix,
                 char suffix)
```
    给定字符串是否被字符包围
    
    参数:
    str - 字符串
    prefix - 前缀
    suffix - 后缀
    
    返回:
    是否包围，空串不包围
  - repeat
```
public static String repeat(char c,
            int count)
```
    重复某个字符
    
    参数:
    c - 被重复的字符
    count - 重复的数目
    
    返回:
    重复字符字符串
  - repeat
```
public static String repeat(String str,
            int count)
```
    重复某个字符串
    
    参数:
    str - 被重复的字符
    count - 重复的数目
    
    返回:
    重复字符字符串
  - equals
```
public static 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 static 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
  - format
```
public static 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 - 参数值
    
    返回:
    格式化后的文本
  - indexedFormat
```
public static String indexedFormat(String pattern,
                   Object... arguments)
```
    有序的格式化文本，使用{number}做为占位符
    例：
    通常使用：format("this is {0} for {1}", "a", "b") -> this is a for b
    
    参数:
    pattern - 文本格式
    arguments - 参数
    
    返回:
    格式化后的文本
  - format
```
public static 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 static byte[] utf8Bytes(String str)
```
    编码字符串，编码为UTF-8
    
    参数:
    str - 字符串
    
    返回:
    编码后的字节码
  - bytes
```
public static byte[] bytes(String str)
```
    编码字符串
    使用系统默认编码
    
    参数:
    str - 字符串
    
    返回:
    编码后的字节码
  - bytes
```
public static byte[] bytes(String str,
           String charset)
```
    编码字符串
    
    参数:
    str - 字符串
    charset - 字符集，如果此字段为空，则解码的结果取决于平台
    
    返回:
    编码后的字节码
  - bytes
```
public static byte[] bytes(String str,
           Charset charset)
```
    编码字符串
    
    参数:
    str - 字符串
    charset - 字符集，如果此字段为空，则解码的结果取决于平台
    
    返回:
    编码后的字节码
  - utf8Str
```
public static String utf8Str(Object obj)
```
    将对象转为字符串
    1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
    
    参数:
    obj - 对象
    
    返回:
    字符串
  - str
```
public static String str(Object obj,
         String charsetName)
```
    将对象转为字符串
    1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
    
    参数:
    obj - 对象
    charsetName - 字符集
    
    返回:
    字符串
  - str
```
public static String str(Object obj,
         Charset charset)
```
    将对象转为字符串
    1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
    
    参数:
    obj - 对象
    charset - 字符集
    
    返回:
    字符串
  - str
```
public static String str(byte[] bytes,
         String charset)
```
    将byte数组转为字符串
    
    参数:
    bytes - byte数组
    charset - 字符集
    
    返回:
    字符串
  - str
```
public static String str(byte[] data,
         Charset charset)
```
    解码字节码
    
    参数:
    data - 字符串
    charset - 字符集，如果此字段为空，则解码的结果取决于平台
    
    返回:
    解码后的字符串
  - str
```
public static String str(Byte[] bytes,
         String charset)
```
    将Byte数组转为字符串
    
    参数:
    bytes - byte数组
    charset - 字符集
    
    返回:
    字符串
  - str
```
public static String str(Byte[] data,
         Charset charset)
```
    解码字节码
    
    参数:
    data - 字符串
    charset - 字符集，如果此字段为空，则解码的结果取决于平台
    
    返回:
    解码后的字符串
  - str
```
public static String str(ByteBuffer data,
         String charset)
```
    将编码的byteBuffer数据转换为字符串
    
    参数:
    data - 数据
    charset - 字符集，如果为空使用当前系统字符集
    
    返回:
    字符串
  - str
```
public static String str(ByteBuffer data,
         Charset charset)
```
    将编码的byteBuffer数据转换为字符串
    
    参数:
    data - 数据
    charset - 字符集，如果为空使用当前系统字符集
    
    返回:
    字符串
  - byteBuffer
```
public static ByteBuffer byteBuffer(String str,
                    String charset)
```
    字符串转换为byteBuffer
    
    参数:
    str - 字符串
    charset - 编码
    
    返回:
    byteBuffer
  - join
```
public static String join(String conjunction,
          Object... objs)
```
    以 conjunction 为分隔符将多个对象转换为字符串
    
    参数:
    conjunction - 分隔符
    objs - 数组
    
    返回:
    连接后的字符串
    另请参阅:
    ArrayUtil.join(Object[], String)
  - toUnderlineCase
```
public static String toUnderlineCase(String camelCaseStr)
```
    将驼峰式命名的字符串转换为下划线方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。
    例如：HelloWorld->hello_world
    
    参数:
    camelCaseStr - 转换前的驼峰式命名的字符串
    
    返回:
    转换后下划线大写方式命名的字符串
  - toCamelCase
```
public static String toCamelCase(String name)
```
    将下划线方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。
    例如：hello_world->HelloWorld
    
    参数:
    name - 转换前的下划线大写方式命名的字符串
    
    返回:
    转换后的驼峰式命名的字符串
  - wrap
```
public static String wrap(String str,
          String prefix,
          String suffix)
```
    包装指定字符串
    
    参数:
    str - 被包装的字符串
    prefix - 前缀
    suffix - 后缀
    
    返回:
    包装后的字符串
  - isWrap
```
public static boolean isWrap(String str,
             String prefix,
             String suffix)
```
    指定字符串是否被包装
    
    参数:
    str - 字符串
    prefix - 前缀
    suffix - 后缀
    
    返回:
    是否被包装
  - isWrap
```
public static boolean isWrap(String str,
             String wrapper)
```
    指定字符串是否被同一字符包装（前后都有这些字符串）
    
    参数:
    str - 字符串
    wrapper - 包装字符串
    
    返回:
    是否被包装
  - isWrap
```
public static boolean isWrap(String str,
             char wrapper)
```
    指定字符串是否被同一字符包装（前后都有这些字符串）
    
    参数:
    str - 字符串
    wrapper - 包装字符
    
    返回:
    是否被包装
  - isWrap
```
public static boolean isWrap(String str,
             char prefixChar,
             char suffixChar)
```
    指定字符串是否被包装
    
    参数:
    str - 字符串
    prefixChar - 前缀
    suffixChar - 后缀
    
    返回:
    是否被包装
  - padPre
```
public static String padPre(String str,
            int minLength,
            char padChar)
```
    补充字符串以满足最小长度 StrUtil.padPre("1", 3, '0');//"001"
    
    参数:
    str - 字符串
    minLength - 最小长度
    padChar - 补充的字符
    
    返回:
    补充后的字符串
  - padEnd
```
public static String padEnd(String str,
            int minLength,
            char padChar)
```
    补充字符串以满足最小长度 StrUtil.padEnd("1", 3, '0');//"100"
    
    参数:
    str - 字符串
    minLength - 最小长度
    padChar - 补充的字符
    
    返回:
    补充后的字符串
  - builder
```
public static StringBuilder builder()
```
    创建StringBuilder对象
    
    返回:
    StringBuilder对象
  - builder
```
public static StringBuilder builder(int capacity)
```
    创建StringBuilder对象
    
    返回:
    StringBuilder对象
  - builder
```
public static StringBuilder builder(String... strs)
```
    创建StringBuilder对象
    
    返回:
    StringBuilder对象
  - getReader
```
public static StringReader getReader(String str)
```
    获得StringReader
    
    参数:
    str - 字符串
    
    返回:
    StringReader
  - getWriter
```
public static StringWriter getWriter()
```
    获得StringWriter
    
    返回:
    StringWriter
  - count
```
public static int count(String content,
        String strForSearch)
```
    统计指定内容中包含指定字符串的数量
    参数为 null 或者 "" 返回 0.
```
 StrUtil.count(null, *)       = 0
 StrUtil.count("", *)         = 0
 StrUtil.count("abba", null)  = 0
 StrUtil.count("abba", "")    = 0
 StrUtil.count("abba", "a")   = 2
 StrUtil.count("abba", "ab")  = 1
 StrUtil.count("abba", "xxx") = 0
 
```
    参数:
    content - 被查找的字符串
    strForSearch - 需要查找的字符串
    
    返回:
    查找到的个数
  - count
```
public static int count(String content,
        char charForSearch)
```
    统计指定内容中包含指定字符的数量
    
    参数:
    content - 内容
    charForSearch - 被统计的字符
    
    返回:
    包含数量

类 StrUtil

字段概要

构造器概要

方法概要

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

字段详细资料

C_SPACE

C_TAB

C_DOT

C_SLASH

C_BACKSLASH

C_CR

C_LF

C_UNDERLINE

C_COMMA

C_DELIM_START

C_DELIM_END

C_COLON

SPACE

TAB

DOT

DOUBLE_DOT

SLASH

BACKSLASH

EMPTY

CR

LF

CRLF

UNDERLINE

COMMA

DELIM_START

DELIM_END

COLON

HTML_NBSP

HTML_AMP

HTML_QUOTE

HTML_LT

HTML_GT

EMPTY_JSON

构造器详细资料

StrUtil

方法详细资料

isBlank

isNotBlank

hasBlank

isAllBlank

isEmpty

isNotEmpty

nullToEmpty

nullToDefault

emptyToNull

hasEmpty

isAllEmpty

trim

trim

trimStart

trimEnd

trim

startWith

startWithIgnoreCase

endWith

endWithIgnoreCase

containsIgnoreCase

getGeneralField

genSetter

genGetter

removeAll

removePreAndLowerFirst

removePreAndLowerFirst

upperFirstAndAddPre

upperFirst

lowerFirst

removePrefix

removePrefixIgnoreCase

removeSuffix

removeSufAndLowerFirst

removeSuffixIgnoreCase

addPrefixIfNot

addSuffixIfNot

cleanBlank