Fun (java-fun 0.5.1 API)

java.lang.Object
- com.github.smallmenu.FunBase
- - com.github.smallmenu.Fun

```
public class Fun
extends FunBase
```
Java With Fun(ctions)

作者:

smallmenu

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static String`	`base64Decode(String str)` base64Decode
`static String`	`base64Encode(String str)` base64Encode
`static String`	`base64UrlSafeDecode(String str)` base64URLDecode
`static String`	`base64UrlSafeEncode(String str)` base64URLEncode 会将 +、/ 替换为 -、_
`static boolean`	`blank(CharSequence str)` 检测字符串是否为空白空白包含：null、""、" "、以及不可见字符如缩紧
`static boolean`	`blankAll(CharSequence... strs)` 检测字符串列表，是否全部为空白
`static boolean`	`blankAny(CharSequence... strs)` 检测字符串列表，是否包含空白，包含任意一个空白返回 true 空白包含：null、""、" "、以及不可见字符如缩紧
`static byte[]`	`bytes(CharSequence str)` 字符串获取 Bytes
`static byte[]`	`bytes(CharSequence str, Charset charset)` 字符串获取 Bytes
`static byte[]`	`bytes(CharSequence str, String charset)` 字符串获取 Bytes
`static boolean`	`contains(CharSequence str, CharSequence searchStr)` 查找字符串是否包含指定字符串
`static boolean`	`containsAny(CharSequence str, CharSequence... searchStrs)` 查找指定字符串，是否包含指定字符列表中的任意一个字符串
`static boolean`	`containsIgnoreCase(CharSequence str, CharSequence searchStr)` 查找字符串是否包含指定字符串，忽略大小写
`static String`	`date()` 返回默认日期时间字符串默认格式：yyyy-MM-dd HH:mm:ss
`static String`	`date(long timestamp)` 根据时间戳，返回默认日期时间字符串默认格式：yyyy-MM-dd HH:mm:ss
`static String`	`date(String pattern)` 根据格式化参数返回日期时间字符串
`static String`	`date(String pattern, long timestamp)` 根据格式化参数，时间戳参数，返回时间字符串
`static boolean`	`empty(CharSequence str)` 检测字符串是否为空空包含 null、空字符串 ""
`static boolean`	`empty(Collection<?> collection)` 检测 Collection 是否为空
`static boolean`	`empty(Map<?,?> map)` 检测 Map 是否为空
`static boolean`	`empty(Object object)` 检测是否为空，（可匹配单一对象）如果对象为 null，返回 true 如果对象为数组，判断数组长度是否为 0 如果对象为字符串，判断字符串长度是否为 0 如果对象为数值类型，判断是否为 0 如果对象为布尔类型，判断是否为 false 其他情况，默认返回 false
`static <T> boolean`	`empty(T[] array)` 检测数组为空（范型）
`static boolean`	`emptyAll(CharSequence... strs)` 检测字符串列表，是否全部为空
`static boolean`	`emptyAny(CharSequence... strs)` 检测字符串列表，是否包含有空值，包含任意一个返回 true
`static boolean`	`endsWith(CharSequence str, CharSequence suffix)` 是否以指定字符串结尾如果给定的字符串和开头字符串都为 null 则返回 true ，否则任意一个值为 null 返回 false 如果给定的字符串不为 null，suffix 字符串为 "" 空字符串，返回true
`static boolean`	`endsWithIgnoreCase(CharSequence str, CharSequence suffix)` 是否以指定字符串结尾，忽略大小写
`static boolean`	`equals(CharSequence str1, CharSequence str2)` 比较两个字符串
`static boolean`	`equalsIgnoreCase(CharSequence str1, CharSequence str2)` 比较两个字符串，忽略大小写
`static long`	`freeMemoryMb()` 返回系统空闲堆内存，单位MB
`static long`	`idDecode(String hash)` Hashid 解密
`static long`	`idDecode(String hash, int minLength)` Hashid 解密
`static long`	`idDecode(String hash, String salt)` Hashid 解密
`static long`	`idDecode(String hash, String salt, int minLength)` Hashid 解密
`static String`	`idEncode(long id)` Hashid 加密
`static String`	`idEncode(long id, int minLength)` Hashid 加密
`static String`	`idEncode(long id, String salt)` Hashid 加密
`static String`	`idEncode(long id, String salt, int minLength)` Hashid 加密
`static int`	`indexOf(CharSequence str, CharSequence searchStr)` 查找字符串，返回索引位置
`static int`	`indexOf(CharSequence str, CharSequence searchStr, int start)` 查找字符串，返回索引位置
`static int`	`indexOfIgnoreCase(CharSequence str, CharSequence searchStr)` 查找字符串，返回索引位置，忽略大小写
`static int`	`indexOfIgnoreCase(CharSequence str, CharSequence searchStr, int start)` 查找字符串，返回索引位置，忽略大小写
`static <T> String`	`join(Iterable<?> iterable, String separator)` 以 separator 为分隔符转换为字符串，支持字符串类容器
`static String`	`join(Iterator<?> iterator, String separator)` 以 separator 为分隔符转换为字符串，支持字符串容器
`static <T> String`	`join(T[] array, CharSequence separator)` 以 separator 为分隔符将数组转换为字符串（范型）
`static String`	`left(String str, int length)` 截取字符串左侧指定长度的子串
`static int`	`length(CharSequence str)` 获取字符串的字符长度，如果为 null 返回 0 使用 String.length 方法，中英文数字均是 1
`static String`	`ltrim(CharSequence str)` 除去字符串左侧的空白
`static boolean`	`matches(Pattern pattern, CharSequence content)` 字符串是否匹配正则
`static boolean`	`matches(String regex, CharSequence content)` 字符串是否匹配正则
`static long`	`maxMemoryMb()` 返回系统最大堆内存（-Xmx），单位MB
`static String`	`md5(String str)` MD5
`static long`	`microtime()` 返回当前 Unix 时间戳（毫秒）
`static String`	`padLeft(CharSequence str, int length)` 左侧填充字符串到指定长度，使用默认空格填充
`static String`	`padLeft(CharSequence str, int length, char padChar)` 右侧填充字符串到最小长度，使用单一字符填充
`static String`	`padLeft(CharSequence str, int length, String padStr)` 左侧填充字符串到指定长度
`static String`	`padRight(CharSequence str, int length)` 右侧填充字符串到指定长度。
`static String`	`padRight(CharSequence str, int length, char padChar)` 右侧填充字符串到指定长度。
`static String`	`padRight(CharSequence str, int length, String padStr)` 右侧填充字符串到指定长度
`static int`	`random()` 获得指定范围内的随机数默认 [0,Integer.MAX_VALUE)
`static int`	`randomInt(int max)` 获得指定范围内的随机数 [0, max)
`static long`	`randomLong(long max)` 获得指定范围内的随机数 [0, max)
`static String`	`randomString(int length)` 获得一个指定长度随机的字符串（只包含数字和字符）
`static String`	`randomStringChar(int length)` 获得一个指定长度只包含字符的随机字符串
`static String`	`randomStringExcepts(int length, String... excepts)` 获得一个指定长度随机的字符串，排除指定的字符串列表集
`static String`	`randomStringNumber(int length)` 获得一个指定长度只包含数字的随机字符串
`static List<String>`	`regexMatch(Pattern pattern, CharSequence content)` 获得匹配字符串的所有分组分组 0，表示全匹配的信息
`static String`	`regexMatch(Pattern pattern, CharSequence content, int groupIndex)` 获得匹配字符串的指定分组分组 0，表示全匹配的信息
`static List<String>`	`regexMatch(String regex, CharSequence content)` 获得匹配字符串的所有分组
`static String`	`regexMatch(String regex, CharSequence content, int groupIndex)` 获得匹配字符串的指定分组分组 0，表示全匹配的信息
`static String`	`remove(CharSequence str, CharSequence remove)` 移除字符串中所有给定字符串
`static String`	`removeAny(CharSequence str, char... chars)` 去除字符串中指定的多个字符集
`static String`	`removeAny(CharSequence str, CharSequence... removes)` 移除字符串中所有给定字符串列表
`static String`	`removeLines(CharSequence str)` 去除字符串中换行符
`static String`	`removePrefix(CharSequence str, CharSequence remove)` 移除字符串左侧中所有给定字符串
`static String`	`removePrefixComplete(CharSequence str, CharSequence remove)` 完整的移除字符串左侧中所有给定字符串
`static String`	`removeSuffix(CharSequence str, CharSequence remove)` 移除字符串右侧中所有给定字符串
`static String`	`removeSuffixComplete(CharSequence str, CharSequence remove)` 完整的移除字符串右侧中所有给定字符串
`static String`	`repeat(char ch, int repeat)` 重复字符到指定次数
`static String`	`repeat(CharSequence str, int repeat)` 重复字符串到指定次数
`static String`	`replace(CharSequence str, CharSequence searchStr, CharSequence replaceStr)` 字符串替换
`static String`	`replaceIgnoreCase(CharSequence str, CharSequence searchStr, CharSequence replaceStr)` 字符串替换，忽略大小写
`static String`	`reverse(String str)` 反转字符串
`static String`	`right(String str, int length)` 截取字符串右侧指定长度的子串
`static String`	`rtrim(CharSequence str)` 除去字符串右侧的空白
`static String`	`sha1(String str)` SHA1
`static String`	`sha256(String str)` SHA256
`static String`	`sha384(String str)` SHA384
`static String`	`sha512(String str)` SHA512
`static String[]`	`split(CharSequence str)` 分割字符串为数组
`static String[]`	`split(CharSequence str, char separator)` 分割字符串为数组
`static String[]`	`split(CharSequence str, CharSequence separator)` 分割字符串为数组
`static List<String>`	`splitToList(CharSequence str)` 分割字符串为列表默认以空白字符分割。
`static List<String>`	`splitToList(CharSequence str, char separator)` 分割字符串为列表默认以空白字符分割。
`static List<String>`	`splitToList(CharSequence str, CharSequence separator)` 分割字符串为列表
`static String[]`	`splitTrim(CharSequence str)` 分割字符串为数组默认以空白字符分割。
`static String[]`	`splitTrim(CharSequence str, char separator)` 分割字符串为数组默认以空白字符分割。
`static String[]`	`splitTrim(CharSequence str, CharSequence separator)` 分割字符串为数组
`static int[]`	`splitTrimToInt(CharSequence str)` 分割字符串为数组默认以空白字符分割。
`static int[]`	`splitTrimToInt(CharSequence str, CharSequence separator)` 分割字符串为数组默认以空白字符分割。
`static List<String>`	`splitTrimToList(CharSequence str)` 分割字符串为列表默认以空白字符分割。
`static List<String>`	`splitTrimToList(CharSequence str, char separator)` 分割字符串为列表默认以空白字符分割。
`static List<String>`	`splitTrimToList(CharSequence str, CharSequence separator)` 分割字符串为列表
`static long[]`	`splitTrimToLong(CharSequence str, CharSequence separator)` 分割字符串为数组默认以空白字符分割。
`static short[]`	`splitTrimToShort(CharSequence str, CharSequence separator)` 分割字符串为数组默认以空白字符分割。
`static boolean`	`startsWith(CharSequence str, CharSequence prefix)` 检测字符串是否以指定字符串开头如果给定的字符串和开头字符串都为 null 则返回 true ，否则任意一个值为 null 返回 false 如果给定的字符串不为 null，prefix 字符串为 "" 空字符串，返回true
`static boolean`	`startsWithIgnoreCase(CharSequence str, CharSequence prefix)` 是否以指定字符串开头，忽略大小写
`static long`	`strtotime()` 返回当前 Unix 时间戳
`static long`	`strtotime(String dateString)` 将通用格式的日期时间字符串，自动为转换时间戳
`static long`	`strtotime(String expString, Long timestamp)` 以提供的时间戳为基准，返回简单表达式计算后的时间戳
`static String`	`substr(CharSequence str, int start)` 字符串截取，等同于 substring
`static String`	`substr(CharSequence str, int start, int length)` 字符串截取
`static String`	`substring(CharSequence str, int start)` 字符串截取
`static String`	`substring(CharSequence str, int start, int end)` 字符串截取
`static long`	`time()` 返回当前 Unix 时间戳（秒）
`static double`	`toDouble(String str)` 字符串转浮点型如果是 null 或者 "" 或者异常，返回 0.0
`static double`	`toDouble(String str, double defaultValue)` 字符串转浮点型如果是 null 或者 "" 或者异常，返回默认值
`static float`	`toFloat(String str)` 字符串转浮点型如果是 null 或者 "" 或者异常，返回 0.0
`static float`	`toFloat(String str, float defaultValue)` 字符串转浮点型如果是 null 或者 "" 或者异常，返回默认值
`static int`	`toInt(String str)` 字符串转整型如果是 null 或者 "" 或者异常，返回 0 如果是小数，返回 0
`static int`	`toInt(String str, int defaultValue)` 字符串转整型如果是 null 或者 "" 或者异常，返回默认值
`static long`	`toLong(String str)` 字符串转整型如果是 null 或者 "" 或异常，返回 0
`static long`	`toLong(String str, long defaultValue)` 字符串转整型如果是 null 或者 "" 或者异常，返回默认值
`static String`	`toLowerCase(CharSequence str)` 字符串转小写
`static String`	`toStr(CharSequence cs)` CharSequence 转 String
`static String`	`toStr(Object obj)` 数组或对象转 String
`static long`	`totalMemoryMb()` 返回系统当前已申请堆内存，单位MB
`static String`	`toUpperCase(CharSequence str)` 字符串转大写
`static String`	`trim(CharSequence str)` 除去字符串头尾部的空白，如果字符串是 null，依然返回 null 和 String.trim 不同，此方法使用 CharUtils.isBlankChar() 来判定空白
`static String`	`trim(CharSequence str, CharSequence trimStr)` 除去字符串两侧的指定字符串集合如果 trimStr 为空，则默认使用空白符号
`static String`	`trimToDefault(CharSequence str, String defaultStr)` 除去字符串头尾部的空白，并处理 null 值。
`static String`	`trimToEmpty(CharSequence str)` 除去字符串头尾部的空白，并处理 null 值如果是 null，返回 ""
`static String`	`trimToNull(CharSequence str)` 除去字符串头尾部的空白，并处理 null 和空字符串 "" 如果字符串是 null 或者 "" ，返回 null
`static String`	`urlNormalize(String url)` 自动格式化补齐 HTTP(s) URL，如缺少协议头
`static URL`	`urlParse(String url)` 安全的解析 HTTP(s) URL，会对 URL 进行验证与格式化，返回 URL 实例
`static boolean`	`urlVerify(String url)` 验证 HTTP(s) 格式
`static long`	`usedMemoryMb()` 返回系统当前已使用堆内存，单位MB

从类继承的方法 com.github.smallmenu.FunBase
base64Encode, base64UrlSafeEncode, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, freeMemory, freeMemoryByte, join, join, join, join, join, join, join, join, maxMemory, maxMemoryByte, md5, randomInt, randomInt, randomLong, randomLong, sha1, sha256, sha384, sha512, totalMemory, totalMemoryByte, usedMemory, usedMemoryByte

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

- 方法详细资料
  - time
```
public static long time()
```
    返回当前 Unix 时间戳（秒）
    
    返回:
    
    long
  - microtime
```
public static long microtime()
```
    返回当前 Unix 时间戳（毫秒）
    
    返回:
    
    long
  - freeMemoryMb
```
public static long freeMemoryMb()
```
    返回系统空闲堆内存，单位MB
    
    返回:
    
    long
  - maxMemoryMb
```
public static long maxMemoryMb()
```
    返回系统最大堆内存（-Xmx），单位MB
    
    返回:
    
    long
  - usedMemoryMb
```
public static long usedMemoryMb()
```
    返回系统当前已使用堆内存，单位MB
    
    返回:
    
    long
  - totalMemoryMb
```
public static long totalMemoryMb()
```
    返回系统当前已申请堆内存，单位MB
    
    返回:
    
    long
  - bytes
```
public static byte[] bytes(CharSequence str)
```
    字符串获取 Bytes
    
    参数:
    
    str - 字符串
    
    返回:
    
    byte[]
  - bytes
```
public static byte[] bytes(CharSequence str,
                           Charset charset)
```
    字符串获取 Bytes
    
    参数:
    
    str - 字符串
    
    charset - 字符集
    
    返回:
    
    byte[]
  - bytes
```
public static byte[] bytes(CharSequence str,
                           String charset)
```
    字符串获取 Bytes
    
    参数:
    
    str - 字符串
    
    charset - 字符集
    
    返回:
    
    byte[]
  - empty
```
public static boolean empty(Object object)
```
    检测是否为空，（可匹配单一对象）
    如果对象为 null，返回 true 如果对象为数组，判断数组长度是否为 0 如果对象为字符串，判断字符串长度是否为 0 如果对象为数值类型，判断是否为 0 如果对象为布尔类型，判断是否为 false 其他情况，默认返回 false
    
    参数:
    
    object - 数组
    
    返回:
    
    boolean
  - empty
```
public static boolean empty(CharSequence str)
```
    检测字符串是否为空
    空包含 null、空字符串 ""
    
    参数:
    
    str - 待检测字符串
    
    返回:
    
    boolean
  - empty
```
public static <T> boolean empty(T[] array)
```
    检测数组为空（范型）
    
    类型参数:
    
    T - T
    
    参数:
    
    array - 数组
    
    返回:
    
    boolean
  - empty
```
public static boolean empty(Map<?,?> map)
```
    检测 Map 是否为空
    
    参数:
    
    map - 列表
    
    返回:
    
    boolean
  - empty
```
public static boolean empty(Collection<?> collection)
```
    检测 Collection 是否为空
    
    参数:
    
    collection - 集合
    
    返回:
    
    boolean
  - emptyAny
```
public static boolean emptyAny(CharSequence... strs)
```
    检测字符串列表，是否包含有空值，包含任意一个返回 true
    
    参数:
    
    strs - 字符串列表
    
    返回:
    
    boolean
  - emptyAll
```
public static boolean emptyAll(CharSequence... strs)
```
    检测字符串列表，是否全部为空
    
    参数:
    
    strs - 字符串列表
    
    返回:
    
    boolean
  - blank
```
public static boolean blank(CharSequence str)
```
    检测字符串是否为空白
    空白包含：null、""、" "、以及不可见字符如缩紧
    
    参数:
    
    str - 待检测字符串
    
    返回:
    
    boolean
  - blankAny
```
public static boolean blankAny(CharSequence... strs)
```
    检测字符串列表，是否包含空白，包含任意一个空白返回 true
    空白包含：null、""、" "、以及不可见字符如缩紧
    
    参数:
    
    strs - 字符串列表
    
    返回:
    
    boolean
  - blankAll
```
public static boolean blankAll(CharSequence... strs)
```
    检测字符串列表，是否全部为空白
    
    参数:
    
    strs - 字符串列表
    
    返回:
    
    boolean
  - matches
```
public static boolean matches(String regex,
                              CharSequence content)
```
    字符串是否匹配正则
    
    参数:
    
    regex - 正则表达式字符串
    
    content - 字符串
    
    返回:
    
    boolean
  - matches
```
public static boolean matches(Pattern pattern,
                              CharSequence content)
```
    字符串是否匹配正则
    
    参数:
    
    pattern - 正则表达式
    
    content - 字符串
    
    返回:
    
    boolean
  - trim
```
public static String trim(CharSequence str)
```
    除去字符串头尾部的空白，如果字符串是 null，依然返回 null
    和 String.trim 不同，此方法使用 CharUtils.isBlankChar() 来判定空白
    
    参数:
    
    str - 待处理字符串
    
    返回:
    
    String
  - ltrim
```
public static String ltrim(CharSequence str)
```
    除去字符串左侧的空白
    
    参数:
    
    str - 待处理字符串
    
    返回:
    
    String
  - rtrim
```
public static String rtrim(CharSequence str)
```
    除去字符串右侧的空白
    
    参数:
    
    str - 待处理字符串
    
    返回:
    
    String
  - trim
```
public static String trim(CharSequence str,
                          CharSequence trimStr)
```
    除去字符串两侧的指定字符串集合
    如果 trimStr 为空，则默认使用空白符号
    
    参数:
    
    str - 待处理字符串
    
    trimStr - 需要处理的字符串集合
    
    返回:
    
    String
  - trimToEmpty
```
public static String trimToEmpty(CharSequence str)
```
    除去字符串头尾部的空白，并处理 null 值
    如果是 null，返回 ""
    
    参数:
    
    str - 待处理字符串
    
    返回:
    
    String
  - trimToDefault
```
public static String trimToDefault(CharSequence str,
                                   String defaultStr)
```
    除去字符串头尾部的空白，并处理 null 值。如果结果为empty，则返回默认值
    
    参数:
    
    str - 待处理字符串
    
    defaultStr - 默认值
    
    返回:
    
    String
  - trimToNull
```
public static String trimToNull(CharSequence str)
```
    除去字符串头尾部的空白，并处理 null 和空字符串 ""
    如果字符串是 null 或者 "" ，返回 null
    
    参数:
    
    str - 待处理字符串
    
    返回:
    
    String
  - toInt
```
public static int toInt(String str)
```
    字符串转整型
    如果是 null 或者 "" 或者异常，返回 0 如果是小数，返回 0
    
    参数:
    
    str - 字符串
    
    返回:
    
    int
  - toInt
```
public static int toInt(String str,
                        int defaultValue)
```
    字符串转整型
    如果是 null 或者 "" 或者异常，返回默认值
    
    参数:
    
    str - 字符串
    
    defaultValue - 默认值
    
    返回:
    
    int
  - toFloat
```
public static float toFloat(String str)
```
    字符串转浮点型
    如果是 null 或者 "" 或者异常，返回 0.0
    
    参数:
    
    str - 字符串
    
    返回:
    
    float
  - toFloat
```
public static float toFloat(String str,
                            float defaultValue)
```
    字符串转浮点型
    如果是 null 或者 "" 或者异常，返回默认值
    
    参数:
    
    str - 字符串
    
    defaultValue - 默认值
    
    返回:
    
    float
  - toDouble
```
public static double toDouble(String str)
```
    字符串转浮点型
    如果是 null 或者 "" 或者异常，返回 0.0
    
    参数:
    
    str - 字符串
    
    返回:
    
    double
  - toDouble
```
public static double toDouble(String str,
                              double defaultValue)
```
    字符串转浮点型
    如果是 null 或者 "" 或者异常，返回默认值
    
    参数:
    
    str - 字符串
    
    defaultValue - 默认值
    
    返回:
    
    double
  - toLong
```
public static long toLong(String str)
```
    字符串转整型
    如果是 null 或者 "" 或异常，返回 0
    
    参数:
    
    str - 字符串
    
    返回:
    
    int
  - toLong
```
public static long toLong(String str,
                          long defaultValue)
```
    字符串转整型
    如果是 null 或者 "" 或者异常，返回默认值
    
    参数:
    
    str - 字符串
    
    defaultValue - 默认值
    
    返回:
    
    long
  - contains
```
public static boolean contains(CharSequence str,
                               CharSequence searchStr)
```
    查找字符串是否包含指定字符串
    
    参数:
    
    str - 字符串
    
    searchStr - 被查找的字符串
    
    返回:
    
    boolean
  - containsIgnoreCase
```
public static boolean containsIgnoreCase(CharSequence str,
                                         CharSequence searchStr)
```
    查找字符串是否包含指定字符串，忽略大小写
    
    参数:
    
    str - 字符串
    
    searchStr - 被查找的字符串
    
    返回:
    
    boolean
  - containsAny
```
public static boolean containsAny(CharSequence str,
                                  CharSequence... searchStrs)
```
    查找指定字符串，是否包含指定字符列表中的任意一个字符串
    
    参数:
    
    str - 指定字符串
    
    searchStrs - 被查找的字符串数组
    
    返回:
    
    是否包含任意一个字符
  - equals
```
public static boolean equals(CharSequence str1,
                             CharSequence str2)
```
    比较两个字符串
    
    参数:
    
    str1 - 要比较的字符串1
    
    str2 - 要比较的字符串2
    
    返回:
    
    boolean
  - equalsIgnoreCase
```
public static boolean equalsIgnoreCase(CharSequence str1,
                                       CharSequence str2)
```
    比较两个字符串，忽略大小写
    
    参数:
    
    str1 - 要比较的字符串1
    
    str2 - 要比较的字符串2
    
    返回:
    
    boolean
  - startsWith
```
public static boolean startsWith(CharSequence str,
                                 CharSequence prefix)
```
    检测字符串是否以指定字符串开头
    如果给定的字符串和开头字符串都为 null 则返回 true ，否则任意一个值为 null 返回 false 如果给定的字符串不为 null，prefix 字符串为 "" 空字符串，返回true
    
    参数:
    
    str - 被监测字符串
    
    prefix - 开头字符串
    
    返回:
    
    boolean
  - startsWithIgnoreCase
```
public static boolean startsWithIgnoreCase(CharSequence str,
                                           CharSequence prefix)
```
    是否以指定字符串开头，忽略大小写
    
    参数:
    
    str - 被监测字符串
    
    prefix - 开头字符串
    
    返回:
    
    boolean
  - endsWith
```
public static boolean endsWith(CharSequence str,
                               CharSequence suffix)
```
    是否以指定字符串结尾
    如果给定的字符串和开头字符串都为 null 则返回 true ，否则任意一个值为 null 返回 false 如果给定的字符串不为 null，suffix 字符串为 "" 空字符串，返回true
    
    参数:
    
    str - 被监测字符串
    
    suffix - 结尾字符串
    
    返回:
    
    boolean
  - endsWithIgnoreCase
```
public static boolean endsWithIgnoreCase(CharSequence str,
                                         CharSequence suffix)
```
    是否以指定字符串结尾，忽略大小写
    
    参数:
    
    str - 被监测字符串
    
    suffix - 结尾字符串
    
    返回:
    
    boolean
  - length
```
public static int length(CharSequence str)
```
    获取字符串的字符长度，如果为 null 返回 0
    使用 String.length 方法，中英文数字均是 1
    
    参数:
    
    str - 字符串
    
    返回:
    
    int
  - toLowerCase
```
public static String toLowerCase(CharSequence str)
```
    字符串转小写
    
    参数:
    
    str - 字符串
    
    返回:
    
    String
  - toUpperCase
```
public static String toUpperCase(CharSequence str)
```
    字符串转大写
    
    参数:
    
    str - 字符串
    
    返回:
    
    String
  - left
```
public static String left(String str,
                          int length)
```
    截取字符串左侧指定长度的子串
    
    参数:
    
    str - 字符串
    
    length - 长度
    
    返回:
    
    String
  - right
```
public static String right(String str,
                           int length)
```
    截取字符串右侧指定长度的子串
    
    参数:
    
    str - 字符串
    
    length - 长度
    
    返回:
    
    String
  - indexOf
```
public static int indexOf(CharSequence str,
                          CharSequence searchStr)
```
    查找字符串，返回索引位置
    
    参数:
    
    str - 字符串
    
    searchStr - 查找字符串
    
    返回:
    
    int
  - indexOf
```
public static int indexOf(CharSequence str,
                          CharSequence searchStr,
                          int start)
```
    查找字符串，返回索引位置
    
    参数:
    
    str - 字符串
    
    searchStr - 查找字符串
    
    start - 起始位置
    
    返回:
    
    int
  - indexOfIgnoreCase
```
public static int indexOfIgnoreCase(CharSequence str,
                                    CharSequence searchStr)
```
    查找字符串，返回索引位置，忽略大小写
    
    参数:
    
    str - 字符串
    
    searchStr - 查找字符串
    
    返回:
    
    int
  - indexOfIgnoreCase
```
public static int indexOfIgnoreCase(CharSequence str,
                                    CharSequence searchStr,
                                    int start)
```
    查找字符串，返回索引位置，忽略大小写
    
    参数:
    
    str - 字符串
    
    searchStr - 查找字符串
    
    start - 起始位置
    
    返回:
    
    int
  - reverse
```
public static String reverse(String str)
```
    反转字符串
    
    参数:
    
    str - 字符串
    
    返回:
    
    String
  - toStr
```
public static String toStr(CharSequence cs)
```
    CharSequence 转 String
    
    参数:
    
    cs - 字符串
    
    返回:
    
    String
  - toStr
```
public static String toStr(Object obj)
```
    数组或对象转 String
    
    参数:
    
    obj - 数组或对象
    
    返回:
    
    String
  - repeat
```
public static String repeat(char ch,
                            int repeat)
```
    重复字符到指定次数
    
    参数:
    
    ch - 字符
    
    repeat - 次数
    
    返回:
    
    String
  - repeat
```
public static String repeat(CharSequence str,
                            int repeat)
```
    重复字符串到指定次数
    
    参数:
    
    str - 字符串
    
    repeat - 次数
    
    返回:
    
    String
  - padLeft
```
public static String padLeft(CharSequence str,
                             int length,
                             char padChar)
```
    右侧填充字符串到最小长度，使用单一字符填充
    
    参数:
    
    str - 待填充字符串
    
    length - 长度
    
    padChar - 填充字符
    
    返回:
    
    String
  - padLeft
```
public static String padLeft(CharSequence str,
                             int length)
```
    左侧填充字符串到指定长度，使用默认空格填充
    
    参数:
    
    str - 待填充字符串
    
    length - 长度
    
    返回:
    
    String
  - padLeft
```
public static String padLeft(CharSequence str,
                             int length,
                             String padStr)
```
    左侧填充字符串到指定长度
    
    参数:
    
    str - 待填充字符串
    
    length - 长度
    
    padStr - 填充字符串
    
    返回:
    
    String
  - padRight
```
public static String padRight(CharSequence str,
                              int length,
                              char padChar)
```
    右侧填充字符串到指定长度。使用单一字符填充
    
    参数:
    
    str - 待填充字符
    
    length - 长度
    
    padChar - 填充字符
    
    返回:
    
    String
  - padRight
```
public static String padRight(CharSequence str,
                              int length)
```
    右侧填充字符串到指定长度。使用默认空格填充
    
    参数:
    
    str - 待填充字符串
    
    length - 长度
    
    返回:
    
    String
  - padRight
```
public static String padRight(CharSequence str,
                              int length,
                              String padStr)
```
    右侧填充字符串到指定长度
    
    参数:
    
    str - 待填充字符串
    
    length - 长度
    
    padStr - 填充字符串
    
    返回:
    
    String
  - split
```
public static String[] split(CharSequence str)
```
    分割字符串为数组
    
    参数:
    
    str - 字符串
    
    返回:
    
    String[]
  - split
```
public static String[] split(CharSequence str,
                             char separator)
```
    分割字符串为数组
    
    参数:
    
    str - 字符串
    
    separator - 分隔符
    
    返回:
    
    String[]
  - split
```
public static String[] split(CharSequence str,
                             CharSequence separator)
```
    分割字符串为数组
    
    参数:
    
    str - 字符串
    
    separator - 分割字符串
    
    返回:
    
    String[]
  - splitToList
```
public static List<String> splitToList(CharSequence str)
```
    分割字符串为列表
    默认以空白字符分割。对分割后的值进行 trim ，并自动忽略空值
    
    参数:
    
    str - 字符串
    
    返回:
    
    String[]
  - splitToList
```
public static List<String> splitToList(CharSequence str,
                                       char separator)
```
    分割字符串为列表
    默认以空白字符分割。对分割后的值进行 trim ，并自动忽略空值
    
    参数:
    
    str - 字符串
    
    separator - 分隔符
    
    返回:
    
    String[]
  - splitToList
```
public static List<String> splitToList(CharSequence str,
                                       CharSequence separator)
```
    分割字符串为列表
    
    参数:
    
    str - 字符串
    
    separator - 分割字符串
    
    返回:
    
    String[]
  - splitTrim
```
public static String[] splitTrim(CharSequence str)
```
    分割字符串为数组
    默认以空白字符分割。对分割后的值进行 trim ，并自动忽略空值
    
    参数:
    
    str - 字符串
    
    返回:
    
    String[]
  - splitTrimToInt
```
public static int[] splitTrimToInt(CharSequence str)
```
    分割字符串为数组
    默认以空白字符分割。对分割后的值进行 trim ，并自动忽略空值
    
    参数:
    
    str - 字符串
    
    返回:
    
    int[]
  - splitTrim
```
public static String[] splitTrim(CharSequence str,
                                 char separator)
```
    分割字符串为数组
    默认以空白字符分割。对分割后的值进行 trim ，并自动忽略空值
    
    参数:
    
    str - 字符串
    
    separator - 分隔符
    
    返回:
    
    String[]
  - splitTrim
```
public static String[] splitTrim(CharSequence str,
                                 CharSequence separator)
```
    分割字符串为数组
    
    参数:
    
    str - 字符串
    
    separator - 分割字符串
    
    返回:
    
    String[]
  - splitTrimToInt
```
public static int[] splitTrimToInt(CharSequence str,
                                   CharSequence separator)
```
    分割字符串为数组
    默认以空白字符分割。对分割后的值进行 trim ，并自动忽略空值
    
    参数:
    
    str - 字符串
    
    separator - 分隔符
    
    返回:
    
    int[]
  - splitTrimToLong
```
public static long[] splitTrimToLong(CharSequence str,
                                     CharSequence separator)
```
    分割字符串为数组
    默认以空白字符分割。对分割后的值进行 trim ，并自动忽略空值
    
    参数:
    
    str - 字符串
    
    separator - 分隔符
    
    返回:
    
    long[]
  - splitTrimToShort
```
public static short[] splitTrimToShort(CharSequence str,
                                       CharSequence separator)
```
    分割字符串为数组
    默认以空白字符分割。对分割后的值进行 trim ，并自动忽略空值
    
    参数:
    
    str - 字符串
    
    separator - 分隔符
    
    返回:
    
    short[]
  - splitTrimToList
```
public static List<String> splitTrimToList(CharSequence str)
```
    分割字符串为列表
    默认以空白字符分割。对分割后的值进行 trim ，并自动忽略空值
    
    参数:
    
    str - 字符串
    
    返回:
    
    String[]
  - splitTrimToList
```
public static List<String> splitTrimToList(CharSequence str,
                                           char separator)
```
    分割字符串为列表
    默认以空白字符分割。对分割后的值进行 trim ，并自动忽略空值
    
    参数:
    
    str - 字符串
    
    separator - 分隔符
    
    返回:
    
    String[]
  - splitTrimToList
```
public static List<String> splitTrimToList(CharSequence str,
                                           CharSequence separator)
```
    分割字符串为列表
    
    参数:
    
    str - 字符串
    
    separator - 分割字符串
    
    返回:
    
    String[]
  - substring
```
public static String substring(CharSequence str,
                               int start)
```
    字符串截取
    
    参数:
    
    str - 字符串
    
    start - 起始索引
    
    返回:
    
    String
  - substring
```
public static String substring(CharSequence str,
                               int start,
                               int end)
```
    字符串截取
    
    参数:
    
    str - 字符串
    
    start - 起始索引
    
    end - 结束索引
    
    返回:
    
    String
  - substr
```
public static String substr(CharSequence str,
                            int start)
```
    字符串截取，等同于 substring
    
    参数:
    
    str - 字符串
    
    start - 起始索引
    
    返回:
    
    String
  - substr
```
public static String substr(CharSequence str,
                            int start,
                            int length)
```
    字符串截取
    
    参数:
    
    str - 字符串
    
    start - 起始索引
    
    length - 截取长度
    
    返回:
    
    String
  - join
```
public static <T> String join(T[] array,
                              CharSequence separator)
```
    以 separator 为分隔符将数组转换为字符串（范型）
    
    类型参数:
    
    T - 范型
    
    参数:
    
    array - 数组
    
    separator - 分隔符
    
    返回:
    
    String
  - join
```
public static <T> String join(Iterable<?> iterable,
                              String separator)
```
    以 separator 为分隔符转换为字符串，支持字符串类容器
    
    类型参数:
    
    T - 范型
    
    参数:
    
    iterable - 字符串容器
    
    separator - 分隔符
    
    返回:
    
    String
  - regexMatch
```
public static String regexMatch(Pattern pattern,
                                CharSequence content,
                                int groupIndex)
```
    获得匹配字符串的指定分组
    分组 0，表示全匹配的信息
    
    参数:
    
    pattern - 正则表达式模式
    
    content - 字符串
    
    groupIndex - 分组
    
    返回:
    
    String
  - regexMatch
```
public static List<String> regexMatch(Pattern pattern,
                                      CharSequence content)
```
    获得匹配字符串的所有分组
    分组 0，表示全匹配的信息
    
    参数:
    
    pattern - 正则表达式模式
    
    content - 字符串
    
    返回:
    
    List
  - regexMatch
```
public static String regexMatch(String regex,
                                CharSequence content,
                                int groupIndex)
```
    获得匹配字符串的指定分组
    分组 0，表示全匹配的信息
    
    参数:
    
    regex - 正则表达式字符串
    
    content - 字符串
    
    groupIndex - 分组
    
    返回:
    
    String
  - regexMatch
```
public static List<String> regexMatch(String regex,
                                      CharSequence content)
```
    获得匹配字符串的所有分组
    
    参数:
    
    regex - 正则表达式字符串
    
    content - 字符串
    
    返回:
    
    List
  - join
```
public static String join(Iterator<?> iterator,
                          String separator)
```
    以 separator 为分隔符转换为字符串，支持字符串容器
    
    参数:
    
    iterator - 迭代器
    
    separator - 分隔符
    
    返回:
    
    String
  - replace
```
public static String replace(CharSequence str,
                             CharSequence searchStr,
                             CharSequence replaceStr)
```
    字符串替换
    
    参数:
    
    str - 待替换的字符串
    
    searchStr - 查找字符串
    
    replaceStr - 替换字符串
    
    返回:
    
    String
  - replaceIgnoreCase
```
public static String replaceIgnoreCase(CharSequence str,
                                       CharSequence searchStr,
                                       CharSequence replaceStr)
```
    字符串替换，忽略大小写
    
    参数:
    
    str - 待替换的字符串
    
    searchStr - 查找字符串
    
    replaceStr - 替换字符串
    
    返回:
    
    String
  - remove
```
public static String remove(CharSequence str,
                            CharSequence remove)
```
    移除字符串中所有给定字符串
    
    参数:
    
    str - 字符串
    
    remove - 被移除的字符串
    
    返回:
    
    String
  - removePrefix
```
public static String removePrefix(CharSequence str,
                                  CharSequence remove)
```
    移除字符串左侧中所有给定字符串
    
    参数:
    
    str - 字符串
    
    remove - 被移除的字符串
    
    返回:
    
    String
  - removePrefixComplete
```
public static String removePrefixComplete(CharSequence str,
                                          CharSequence remove)
```
    完整的移除字符串左侧中所有给定字符串
    
    参数:
    
    str - 字符串
    
    remove - 被移除的字符串
    
    返回:
    
    String
  - removeSuffix
```
public static String removeSuffix(CharSequence str,
                                  CharSequence remove)
```
    移除字符串右侧中所有给定字符串
    
    参数:
    
    str - 字符串
    
    remove - 被移除的字符串
    
    返回:
    
    String
  - removeSuffixComplete
```
public static String removeSuffixComplete(CharSequence str,
                                          CharSequence remove)
```
    完整的移除字符串右侧中所有给定字符串
    
    参数:
    
    str - 字符串
    
    remove - 被移除的字符串
    
    返回:
    
    String
  - removeAny
```
public static String removeAny(CharSequence str,
                               CharSequence... removes)
```
    移除字符串中所有给定字符串列表
    
    参数:
    
    str - 字符串
    
    removes - 被移除的字符串，一个或多个
    
    返回:
    
    String
  - removeAny
```
public static String removeAny(CharSequence str,
                               char... chars)
```
    去除字符串中指定的多个字符集
    
    参数:
    
    str - 字符串
    
    chars - 字符列表
    
    返回:
    
    String
  - removeLines
```
public static String removeLines(CharSequence str)
```
    去除字符串中换行符
    
    参数:
    
    str - 字符串
    
    返回:
    
    String
  - date
```
public static String date()
```
    返回默认日期时间字符串
    默认格式：yyyy-MM-dd HH:mm:ss
    
    返回:
    
    String
  - date
```
public static String date(long timestamp)
```
    根据时间戳，返回默认日期时间字符串
    默认格式：yyyy-MM-dd HH:mm:ss
    
    参数:
    
    timestamp - 时间戳
    
    返回:
    
    String
  - date
```
public static String date(String pattern)
```
    根据格式化参数返回日期时间字符串
    
    参数:
    
    pattern - 日期时间格式
    
    返回:
    
    String
  - date
```
public static String date(String pattern,
                          long timestamp)
```
    根据格式化参数，时间戳参数，返回时间字符串
    
    参数:
    
    pattern - 日期时间格式
    
    timestamp - 时间戳
    
    返回:
    
    String
  - strtotime
```
public static long strtotime()
```
    返回当前 Unix 时间戳
    
    返回:
    
    long
  - strtotime
```
public static long strtotime(String dateString)
```
    将通用格式的日期时间字符串，自动为转换时间戳
    
    参数:
    
    dateString - 日期时间字符串
    
    返回:
    
    long
  - strtotime
```
public static long strtotime(String expString,
                             Long timestamp)
```
    以提供的时间戳为基准，返回简单表达式计算后的时间戳
    
    参数:
    
    expString - 时期时间字符串
    
    timestamp - 时间戳
    
    返回:
    
    long
  - random
```
public static int random()
```
    获得指定范围内的随机数
    默认 [0,Integer.MAX_VALUE)
    
    返回:
    
    int
  - randomInt
```
public static int randomInt(int max)
```
    获得指定范围内的随机数 [0, max)
    
    参数:
    
    max - 限制随机数的范围
    
    返回:
    
    int
  - randomLong
```
public static long randomLong(long max)
```
    获得指定范围内的随机数 [0, max)
    
    参数:
    
    max - 限制随机数的范围
    
    返回:
    
    随机数
  - randomString
```
public static String randomString(int length)
```
    获得一个指定长度随机的字符串（只包含数字和字符）
    
    参数:
    
    length - 字符串的长度
    
    返回:
    
    String
  - randomStringExcepts
```
public static String randomStringExcepts(int length,
                                         String... excepts)
```
    获得一个指定长度随机的字符串，排除指定的字符串列表集
    
    参数:
    
    length - 字符串的长度
    
    excepts - 待排除列表
    
    返回:
    
    String
  - randomStringNumber
```
public static String randomStringNumber(int length)
```
    获得一个指定长度只包含数字的随机字符串
    
    参数:
    
    length - 字符串的长度
    
    返回:
    
    String
  - randomStringChar
```
public static String randomStringChar(int length)
```
    获得一个指定长度只包含字符的随机字符串
    
    参数:
    
    length - 字符串的长度
    
    返回:
    
    String
  - base64Encode
```
public static String base64Encode(String str)
```
    base64Encode
    
    参数:
    
    str - 字符串
    
    返回:
    
    String
  - base64Decode
```
public static String base64Decode(String str)
```
    base64Decode
    
    参数:
    
    str - Base64字符串
    
    返回:
    
    String
  - base64UrlSafeEncode
```
public static String base64UrlSafeEncode(String str)
```
    base64URLEncode
    会将 +、/ 替换为 -、_
    
    参数:
    
    str - 字符串
    
    返回:
    
    String
  - base64UrlSafeDecode
```
public static String base64UrlSafeDecode(String str)
```
    base64URLDecode
    
    参数:
    
    str - Base64字符串
    
    返回:
    
    String
  - md5
```
public static String md5(String str)
```
    MD5
    
    参数:
    
    str - 字符串
    
    返回:
    
    String
  - sha1
```
public static String sha1(String str)
```
    SHA1
    
    参数:
    
    str - 字符串
    
    返回:
    
    String
  - sha256
```
public static String sha256(String str)
```
    SHA256
    
    参数:
    
    str - 字符串
    
    返回:
    
    String
  - sha384
```
public static String sha384(String str)
```
    SHA384
    
    参数:
    
    str - 字符串
    
    返回:
    
    String
  - sha512
```
public static String sha512(String str)
```
    SHA512
    
    参数:
    
    str - 字符串
    
    返回:
    
    String
  - idEncode
```
public static String idEncode(long id)
```
    Hashid 加密
    
    参数:
    
    id - ID
    
    返回:
    
    String
  - idEncode
```
public static String idEncode(long id,
                              int minLength)
```
    Hashid 加密
    
    参数:
    
    id - ID
    
    minLength - 最小长度
    
    返回:
    
    String
  - idEncode
```
public static String idEncode(long id,
                              String salt)
```
    Hashid 加密
    
    参数:
    
    id - ID
    
    salt - 盐
    
    返回:
    
    String
  - idEncode
```
public static String idEncode(long id,
                              String salt,
                              int minLength)
```
    Hashid 加密
    
    参数:
    
    id - ID
    
    minLength - 最小长度
    
    salt - 盐
    
    返回:
    
    String
  - idDecode
```
public static long idDecode(String hash)
```
    Hashid 解密
    
    参数:
    
    hash - Hash字符串
    
    返回:
    
    long
  - idDecode
```
public static long idDecode(String hash,
                            int minLength)
```
    Hashid 解密
    
    参数:
    
    hash - Hash 字符串
    
    minLength - 最小长度
    
    返回:
    
    long
  - idDecode
```
public static long idDecode(String hash,
                            String salt)
```
    Hashid 解密
    
    参数:
    
    hash - Hash 字符串
    
    salt - 盐
    
    返回:
    
    long
  - idDecode
```
public static long idDecode(String hash,
                            String salt,
                            int minLength)
```
    Hashid 解密
    
    参数:
    
    hash - Hash 字符串
    
    salt - 盐
    
    minLength - 最小长度
    
    返回:
    
    long
  - urlParse
```
public static URL urlParse(String url)
```
    安全的解析 HTTP(s) URL，会对 URL 进行验证与格式化，返回 URL 实例
    
    参数:
    
    url - 字符串
    
    返回:
    
    URL
  - urlVerify
```
public static boolean urlVerify(String url)
```
    验证 HTTP(s) 格式
    
    参数:
    
    url - URL 字符串
    
    返回:
    
    boolean
  - urlNormalize
```
public static String urlNormalize(String url)
```
    自动格式化补齐 HTTP(s) URL，如缺少协议头
    
    参数:
    
    url - URL字符串
    
    返回:
    
    String

类 Fun

方法概要

从类继承的方法 com.github.smallmenu.FunBase

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

方法详细资料

time

microtime

freeMemoryMb

maxMemoryMb

usedMemoryMb

totalMemoryMb

bytes

bytes

bytes

empty

empty

empty

empty

empty

emptyAny

emptyAll

blank

blankAny

blankAll

matches

matches

trim

ltrim

rtrim

trim

trimToEmpty

trimToDefault

trimToNull

toInt

toInt

toFloat

toFloat

toDouble

toDouble

toLong

toLong

contains

containsIgnoreCase

containsAny

equals

equalsIgnoreCase

startsWith

startsWithIgnoreCase

endsWith

endsWithIgnoreCase

length

toLowerCase

toUpperCase

left

right

indexOf

indexOf

indexOfIgnoreCase

indexOfIgnoreCase

reverse

toStr

toStr

repeat

repeat

padLeft

padLeft

padLeft

padRight

padRight

padRight

split

split

split

splitToList

splitToList

splitToList

splitTrim

splitTrimToInt

splitTrim

splitTrim