Chars (polaris-toolkit 3.2.25 API)

java.lang.Object
- io.polaris.core.lang.primitive.Chars

```
public class Chars
extends Object
```
从以下版本开始:

1.8

作者:

Qt

构造器概要

构造器
构造器和说明

Chars()

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

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static boolean`	`contains(char[] array, char value)` 数组中是否包含元素
`static int`	`digit16(int b)` 获取给定字符的16进制数值
`static boolean`	`equals(char c1, char c2, boolean caseInsensitive)` 比较两个字符是否相同
`static int`	`getType(int c)` 获取字符类型
`static int`	`indexOf(char[] array, char value)` 返回数组中指定元素所在位置，未找到返回 -1
`static boolean`	`isAscii(char ch)` 是否为ASCII字符，ASCII字符位于0~127之间 Chars.isAscii('a') = true Chars.isAscii('A') = true Chars.isAscii('3') = true Chars.isAscii('-') = true Chars.isAscii('\n') = true Chars.isAscii('©') = false
`static boolean`	`isAsciiControl(char ch)` 是否为ASCII控制符（不可见字符），控制符位于0~31和127 Chars.isAsciiControl('a') = false Chars.isAsciiControl('A') = false Chars.isAsciiControl('3') = false Chars.isAsciiControl('-') = false Chars.isAsciiControl('\n') = true Chars.isAsciiControl('©') = false
`static boolean`	`isAsciiPrintable(char ch)` 是否为可见ASCII字符，可见字符位于32~126之间 Chars.isAsciiPrintable('a') = true Chars.isAsciiPrintable('A') = true Chars.isAsciiPrintable('3') = true Chars.isAsciiPrintable('-') = true Chars.isAsciiPrintable('\n') = false Chars.isAsciiPrintable('©') = false
`static boolean`	`isBlankChar(char c)` 是否空白符空白符包括空格、制表符、全角空格和不间断空格
`static boolean`	`isBlankChar(int c)` 是否空白符空白符包括空格、制表符、全角空格和不间断空格
`static boolean`	`isChar(Object value)` 给定对象对应的类是否为字符类，字符类包括： Character.class char.class
`static boolean`	`isCharClass(Class<?> clazz)` 给定类名是否为字符类，字符类包括： Character.class char.class
`static boolean`	`isEmoji(char c)` 判断是否为emoji表情符
`static boolean`	`isEmpty(char[] array)` 数组是否为空
`static boolean`	`isFileSeparator(char c)` 是否为Windows或者Linux（Unix）文件分隔符 Windows平台下分隔符为\，Linux（Unix）为/
`static boolean`	`isHexChar(char c)` 是否为16进制规范的字符，判断是否为如下字符 1. 0~9 2. a~f 4.
`static boolean`	`isLetter(char ch)` 判断是否为字母（包括大写字母和小写字母）字母包括A~Z和a~z Chars.isLetter('a') = true Chars.isLetter('A') = true Chars.isLetter('3') = false Chars.isLetter('-') = false Chars.isLetter('\n') = false Chars.isLetter('©') = false
`static boolean`	`isLetterLower(char ch)` 检查字符是否为小写字母，小写字母指a~z Chars.isLetterLower('a') = true Chars.isLetterLower('A') = false Chars.isLetterLower('3') = false Chars.isLetterLower('-') = false Chars.isLetterLower('\n') = false Chars.isLetterLower('©') = false
`static boolean`	`isLetterOrNumber(char ch)` 是否为字母或数字，包括A~Z、a~z、0~9 Chars.isLetterOrNumber('a') = true Chars.isLetterOrNumber('A') = true Chars.isLetterOrNumber('3') = true Chars.isLetterOrNumber('-') = false Chars.isLetterOrNumber('\n') = false Chars.isLetterOrNumber('©') = false
`static boolean`	`isLetterUpper(char ch)` 判断是否为大写字母，大写字母包括A~Z Chars.isLetterUpper('a') = false Chars.isLetterUpper('A') = true Chars.isLetterUpper('3') = false Chars.isLetterUpper('-') = false Chars.isLetterUpper('\n') = false Chars.isLetterUpper('©') = false
`static boolean`	`isNotEmpty(char[] array)` 数组是否为非空
`static boolean`	`isNumber(char ch)` 检查是否为数字字符，数字字符指0~9 Chars.isNumber('a') = false Chars.isNumber('A') = false Chars.isNumber('3') = true Chars.isNumber('-') = false Chars.isNumber('\n') = false Chars.isNumber('©') = false
`static boolean`	`isSorted(char[] array)` 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
`static boolean`	`isSortedAsc(char[] array)` 检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
`static boolean`	`isSortedDesc(char[] array)` 检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
`static char[]`	`join(char[]... arrays)` 将多个数组合并在一起忽略null的数组
`static int`	`lastIndexOf(char[] array, char value)` 返回数组中指定元素所在最后的位置，未找到返回 -1
`static char`	`max(char... numberArray)` 取最大值
`static char`	`min(char... numberArray)` 取最小值
`static char[]`	`remove(char[] array, int index)` 移除数组中对应位置的元素 copy from commons-lang
`static char[]`	`removeElement(char[] array, char element)` 移除数组中指定的元素只会移除匹配到的第一个元素 copy from commons-lang
`static char[]`	`reverse(char[] array)` 反转数组，会变更原数组
`static char[]`	`reverse(char[] array, int startIndexInclusive, int endIndexExclusive)` 反转数组，会变更原数组
`static char[]`	`shuffle(char[] array)` 打乱数组顺序，会变更原数组
`static char[]`	`shuffle(char[] array, Random random)` 打乱数组顺序，会变更原数组
`static char[]`	`sub(char[] array, int start, int end)` 获取子数组
`static char[]`	`swap(char[] array, int index1, int index2)` 交换数组中两个位置的值
`static char`	`toCloseByNumber(int number)` 将[1-20]数字转换为带圈的字符： 1 -》 '①' 12 -》 '⑫' 20 -》 '⑳' 也称作：封闭式字符，英文：Enclosed Alphanumerics
`static char`	`toCloseChar(char c)` 将字母、数字转换为带圈的字符： '1' -》 '①' 'A' -》 'Ⓐ' 'a' -》 'ⓐ' 获取带圈数字 /封闭式字母数字，从1-20,超过1-20报错
`static String`	`toString(char c)` 字符转为字符串如果为ASCII字符，使用缓存
`static char[]`	`unwrap(Character... values)` 包装类数组转为原始类型数组
`static Character[]`	`wrap(char... values)` 将原始类型数组包装为包装类型

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

- 构造器详细资料
  - Chars
```
public Chars()
```
- 方法详细资料
  - isEmpty
```
public static boolean isEmpty(char[] array)
```
    数组是否为空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为空
  - isNotEmpty
```
public static boolean isNotEmpty(char[] array)
```
    数组是否为非空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为非空
  - join
```
public static char[] join(char[]... arrays)
```
    将多个数组合并在一起
    忽略null的数组
    
    参数:
    
    arrays - 数组集合
    
    返回:
    
    合并后的数组
  - indexOf
```
public static int indexOf(char[] array,
                          char value)
```
    返回数组中指定元素所在位置，未找到返回 -1
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回 -1
  - lastIndexOf
```
public static int lastIndexOf(char[] array,
                              char value)
```
    返回数组中指定元素所在最后的位置，未找到返回 -1
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回 -1
  - contains
```
public static boolean contains(char[] array,
                               char value)
```
    数组中是否包含元素
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    是否包含
  - wrap
```
public static Character[] wrap(char... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    
    values - 原始类型数组
    
    返回:
    
    包装类型数组
  - unwrap
```
public static char[] unwrap(Character... values)
```
    包装类数组转为原始类型数组
    
    参数:
    
    values - 包装类型数组
    
    返回:
    
    原始类型数组
  - sub
```
public static char[] sub(char[] array,
                         int start,
                         int end)
```
    获取子数组
    
    参数:
    
    array - 数组
    
    start - 开始位置（包括）
    
    end - 结束位置（不包括）
    
    返回:
    
    新的数组
    
    另请参阅:
    
    Arrays.copyOfRange(Object[], int, int)
  - remove
```
public static char[] remove(char[] array,
                            int index)
                     throws IllegalArgumentException
```
    移除数组中对应位置的元素
    copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    index - 位置，如果位置小于0或者大于长度，返回原数组
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
  - removeElement
```
public static char[] removeElement(char[] array,
                                   char element)
                            throws IllegalArgumentException
```
    移除数组中指定的元素
    只会移除匹配到的第一个元素 copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    element - 要移除的元素
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
  - reverse
```
public static char[] reverse(char[] array,
                             int startIndexInclusive,
                             int endIndexExclusive)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    startIndexInclusive - 起始位置（包含）
    
    endIndexExclusive - 结束位置（不包含）
    
    返回:
    
    变更后的原数组
  - reverse
```
public static char[] reverse(char[] array)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    返回:
    
    变更后的原数组
  - min
```
public static char min(char... numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
  - max
```
public static char max(char... numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
  - shuffle
```
public static char[] shuffle(char[] array)
```
    打乱数组顺序，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    返回:
    
    打乱后的数组
  - shuffle
```
public static char[] shuffle(char[] array,
                             Random random)
```
    打乱数组顺序，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    random - 随机数生成器
    
    返回:
    
    打乱后的数组
  - swap
```
public static char[] swap(char[] array,
                          int index1,
                          int index2)
```
    交换数组中两个位置的值
    
    参数:
    
    array - 数组
    
    index1 - 位置1
    
    index2 - 位置2
    
    返回:
    
    交换后的数组，与传入数组为同一对象
  - isSorted
```
public static boolean isSorted(char[] array)
```
    检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
    
    参数:
    
    array - 数组
    
    返回:
    
    数组是否升序
  - isSortedAsc
```
public static boolean isSortedAsc(char[] array)
```
    检查数组是否升序，即array[i] <= array[i+1]，若传入空数组，则返回false
    
    参数:
    
    array - 数组
    
    返回:
    
    数组是否升序
  - isSortedDesc
```
public static boolean isSortedDesc(char[] array)
```
    检查数组是否降序，即array[i] >= array[i+1]，若传入空数组，则返回false
    
    参数:
    
    array - 数组
    
    返回:
    
    数组是否降序
  - isAscii
```
public static boolean isAscii(char ch)
```
    是否为ASCII字符，ASCII字符位于0~127之间
```
   Chars.isAscii('a')  = true
   Chars.isAscii('A')  = true
   Chars.isAscii('3')  = true
   Chars.isAscii('-')  = true
   Chars.isAscii('\n') = true
   Chars.isAscii('©') = false
 
```
    参数:
    
    ch - 被检查的字符处
    
    返回:
    
    true表示为ASCII字符，ASCII字符位于0~127之间
  - isAsciiPrintable
```
public static boolean isAsciiPrintable(char ch)
```
    是否为可见ASCII字符，可见字符位于32~126之间
```
   Chars.isAsciiPrintable('a')  = true
   Chars.isAsciiPrintable('A')  = true
   Chars.isAsciiPrintable('3')  = true
   Chars.isAsciiPrintable('-')  = true
   Chars.isAsciiPrintable('\n') = false
   Chars.isAsciiPrintable('©') = false
 
```
    参数:
    
    ch - 被检查的字符处
    
    返回:
    
    true表示为ASCII可见字符，可见字符位于32~126之间
  - isAsciiControl
```
public static boolean isAsciiControl(char ch)
```
    是否为ASCII控制符（不可见字符），控制符位于0~31和127
```
   Chars.isAsciiControl('a')  = false
   Chars.isAsciiControl('A')  = false
   Chars.isAsciiControl('3')  = false
   Chars.isAsciiControl('-')  = false
   Chars.isAsciiControl('\n') = true
   Chars.isAsciiControl('©') = false
 
```
    参数:
    
    ch - 被检查的字符
    
    返回:
    
    true表示为控制符，控制符位于0~31和127
  - isLetter
```
public static boolean isLetter(char ch)
```
    判断是否为字母（包括大写字母和小写字母）
    字母包括A~Z和a~z
```
   Chars.isLetter('a')  = true
   Chars.isLetter('A')  = true
   Chars.isLetter('3')  = false
   Chars.isLetter('-')  = false
   Chars.isLetter('\n') = false
   Chars.isLetter('©') = false
 
```
    参数:
    
    ch - 被检查的字符
    
    返回:
    
    true表示为字母（包括大写字母和小写字母）字母包括A~Z和a~z
  - isLetterUpper
```
public static boolean isLetterUpper(char ch)
```
    判断是否为大写字母，大写字母包括A~Z
```
   Chars.isLetterUpper('a')  = false
   Chars.isLetterUpper('A')  = true
   Chars.isLetterUpper('3')  = false
   Chars.isLetterUpper('-')  = false
   Chars.isLetterUpper('\n') = false
   Chars.isLetterUpper('©') = false
 
```
    参数:
    
    ch - 被检查的字符
    
    返回:
    
    true表示为大写字母，大写字母包括A~Z
  - isLetterLower
```
public static boolean isLetterLower(char ch)
```
    检查字符是否为小写字母，小写字母指a~z
```
   Chars.isLetterLower('a')  = true
   Chars.isLetterLower('A')  = false
   Chars.isLetterLower('3')  = false
   Chars.isLetterLower('-')  = false
   Chars.isLetterLower('\n') = false
   Chars.isLetterLower('©') = false
 
```
    参数:
    
    ch - 被检查的字符
    
    返回:
    
    true表示为小写字母，小写字母指a~z
  - isNumber
```
public static boolean isNumber(char ch)
```
    检查是否为数字字符，数字字符指0~9
```
   Chars.isNumber('a')  = false
   Chars.isNumber('A')  = false
   Chars.isNumber('3')  = true
   Chars.isNumber('-')  = false
   Chars.isNumber('\n') = false
   Chars.isNumber('©') = false
 
```
    参数:
    
    ch - 被检查的字符
    
    返回:
    
    true表示为数字字符，数字字符指0~9
  - isHexChar
```
public static boolean isHexChar(char c)
```
    是否为16进制规范的字符，判断是否为如下字符
```
 1. 0~9
 2. a~f
 4. A~F
 
```
    参数:
    
    c - 字符
    
    返回:
    
    是否为16进制规范的字符
  - isLetterOrNumber
```
public static boolean isLetterOrNumber(char ch)
```
    是否为字母或数字，包括A~Z、a~z、0~9
```
   Chars.isLetterOrNumber('a')  = true
   Chars.isLetterOrNumber('A')  = true
   Chars.isLetterOrNumber('3')  = true
   Chars.isLetterOrNumber('-')  = false
   Chars.isLetterOrNumber('\n') = false
   Chars.isLetterOrNumber('©') = false
 
```
    参数:
    
    ch - 被检查的字符
    
    返回:
    
    true表示为字母或数字，包括A~Z、a~z、0~9
  - toString
```
public static String toString(char c)
```
    字符转为字符串
    如果为ASCII字符，使用缓存
    
    参数:
    
    c - 字符
    
    返回:
    
    字符串
    
    另请参阅:
    
    ASCIIStrCache#toString(char)
  - isCharClass
```
public static boolean isCharClass(Class<?> clazz)
```
    给定类名是否为字符类，字符类包括：
```
 Character.class
 char.class
 
```
    参数:
    
    clazz - 被检查的类
    
    返回:
    
    true表示为字符类
  - isChar
```
public static boolean isChar(Object value)
```
    给定对象对应的类是否为字符类，字符类包括：
```
 Character.class
 char.class
 
```
    参数:
    
    value - 被检查的对象
    
    返回:
    
    true表示为字符类
  - isBlankChar
```
public static boolean isBlankChar(char c)
```
    是否空白符
    空白符包括空格、制表符、全角空格和不间断空格
    
    参数:
    
    c - 字符
    
    返回:
    
    是否空白符
    
    另请参阅:
    
    Character.isWhitespace(int), Character.isSpaceChar(int)
  - isBlankChar
```
public static boolean isBlankChar(int c)
```
    是否空白符
    空白符包括空格、制表符、全角空格和不间断空格
    
    参数:
    
    c - 字符
    
    返回:
    
    是否空白符
    
    另请参阅:
    
    Character.isWhitespace(int), Character.isSpaceChar(int)
  - isEmoji
```
public static boolean isEmoji(char c)
```
    判断是否为emoji表情符
    
    参数:
    
    c - 字符
    
    返回:
    
    是否为emoji
  - isFileSeparator
```
public static boolean isFileSeparator(char c)
```
    是否为Windows或者Linux（Unix）文件分隔符
    Windows平台下分隔符为\，Linux（Unix）为/
    
    参数:
    
    c - 字符
    
    返回:
    
    是否为Windows或者Linux（Unix）文件分隔符
  - equals
```
public static boolean equals(char c1,
                             char c2,
                             boolean caseInsensitive)
```
    比较两个字符是否相同
    
    参数:
    
    c1 - 字符1
    
    c2 - 字符2
    
    caseInsensitive - 是否忽略大小写
    
    返回:
    
    是否相同
  - getType
```
public static int getType(int c)
```
    获取字符类型
    
    参数:
    
    c - 字符
    
    返回:
    
    字符类型
  - digit16
```
public static int digit16(int b)
```
    获取给定字符的16进制数值
    
    参数:
    
    b - 字符
    
    返回:
    
    16进制字符
  - toCloseChar
```
public static char toCloseChar(char c)
```
    将字母、数字转换为带圈的字符：
```
     '1' -》 '①'
     'A' -》 'Ⓐ'
     'a' -》 'ⓐ'
 
```
    获取带圈数字 /封闭式字母数字，从1-20,超过1-20报错
    参数:
    
    c - 被转换的字符，如果字符不支持转换，返回原字符
    
    返回:
    
    转换后的字符
    
    另请参阅:
    
    Unicode_symbols, Alphanumerics
  - toCloseByNumber
```
public static char toCloseByNumber(int number)
```
    将[1-20]数字转换为带圈的字符：
```
     1 -》 '①'
     12 -》 '⑫'
     20 -》 '⑳'
 
```
    也称作：封闭式字符，英文：Enclosed Alphanumerics
    参数:
    
    number - 被转换的数字
    
    返回:
    
    转换后的字符
    
    另请参阅:
    
    维基百科wikipedia-Unicode_symbols, 维基百科wikipedia-Unicode字符列表, coolsymbol, 百度百科特殊字符

类 Chars

构造器概要

方法概要

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

构造器详细资料

Chars

方法详细资料

isEmpty

isNotEmpty

join

indexOf

lastIndexOf

contains

wrap

unwrap

sub

remove

removeElement

reverse

reverse

min

max

shuffle

shuffle

swap

isSorted

isSortedAsc

isSortedDesc

isAscii

isAsciiPrintable

isAsciiControl

isLetter

isLetterUpper

isLetterLower

isNumber

isHexChar

isLetterOrNumber

toString

isCharClass

isChar

isBlankChar

isBlankChar

isEmoji

isFileSeparator

equals

getType

digit16

toCloseChar

toCloseByNumber