Module  java.base
软件包  java.lang

Class Character

  • All Implemented Interfaces:
    SerializableComparable<Character>


    public final class Character
    extends Object
    implements Serializable, Comparable<Character>
    Character类包装一个对象中的原始类型char的值。 类型为Character的对象包含一个单一字段,其类型为char

    此外,该类还提供了几种方法来确定字符的类别(小写字母,数字等),并将字符从大写转换为小写,反之亦然。

    字符信息基于Unicode标准版本8.0.0。

    的方法和类的数据Character通过在UnicodeData文件的是由Unicode Consortium维护的Unicode字符数据库的一部分的信息来定义。 该文件为每个定义的Unicode代码点或字符范围指定各种属性,包括名称和常规类别。

    该文件及其描述可从Unicode Consortium获得:

    Unicode Character Representations

    char数据类型(因此Character对象封装的值)基于原始Unicode规范,其将字符定义为固定宽度的16位实体。 Unicode标准已经被更改为允许其表示需要超过16位的字符。 法定代码点的范围现在是U + 0000到U + 10FFFF,称为Unicode标量值 (请参阅Unicode标准中U + n符号的 definition

    The set of characters from U+0000 to U+FFFF有时被称为基本多语言平面(BMP) 其代码点大于U + FFFF的Characters称为补充字符 s。 Java平台在char阵列和StringStringBuffer类中使用UTF-16表示形式。 在该表示中,补充字符表示为char值,第一个来自高替代范围(\ uD800- \ uDBFF),第二个来自低代理范围(\ uDC00- \ uDFFF)。

    因此,值char表示基本多语言平面(BMP)代码点,包括代码代码点或UTF-16编码的代码单元。 一个int值代表所有Unicode代码点,包括补充代码点。 int的较低(最低有效)21位用于表示Unicode码点,而高(最高有效)11位必须为零。 除非另有说明,关于补充字符和char值的行为如下:

    • 仅接受char值的方法不能支持补充字符。 他们将char值从代理范围视为未定义的字符。 例如, Character.isLetter('\uD840')返回false ,即使这个特定值如果后面是字符串中的任何低代理值都将代表一个字母。
    • 接受int值的方法支持所有Unicode字符,包括补充字符。 例如, Character.isLetter(0x2F81A)返回true因为代码点值代表一个字母(CJK表意文字)。

    在Java SE API文档中, Unicode代码点用于U + 0000和U + 10FFFF之间范围内的字符值, Unicode代码单元用于作为UTF-16编码的代码单位的16位char值。 有关Unicode术语的更多信息,请参阅Unicode Glossary

    从以下版本开始:
    1.0
    另请参见:
    Serialized Form
    • 构造方法摘要

      构造方法  
      Constructor 描述
      Character​(char value)
      已过时。
      很少使用这个构造函数。 静态工厂valueOf(char)通常是一个更好的选择,因为它可能产生明显更好的空间和时间性能。
    • 方法摘要

      所有方法  静态方法  接口方法  具体的方法  弃用的方法 
      Modifier and Type 方法 描述
      static int charCount​(int codePoint)
      确定表示指定字符(Unicode代码点)所需的 char值。
      char charValue​()
      返回此 Character对象的值。
      static int codePointAt​(char[] a, int index)
      返回 char数组的给定索引处的代码点。
      static int codePointAt​(char[] a, int index, int limit)
      返回 char数组的给定索引处的代码点,其中只能使用 index小于 limit数组元素。
      static int codePointAt​(CharSequence seq, int index)
      返回 CharSequence给定索引处的代码点。
      static int codePointBefore​(char[] a, int index)
      返回 char数组的给定索引之前的代码点。
      static int codePointBefore​(char[] a, int index, int start)
      返回 char数组的给定索引之前的代码点,其中只能使用 index大于或等于 start数组元素。
      static int codePointBefore​(CharSequence seq, int index)
      返回 CharSequence给定索引之前的代码点。
      static int codePointCount​(char[] a, int offset, int count)
      返回 char数组参数的子阵列中的Unicode代码点数。
      static int codePointCount​(CharSequence seq, int beginIndex, int endIndex)
      返回指定字符序列的文本范围内的Unicode代码点数。
      static int codePointOf​(String name)
      返回由给定的Unicode字符名称指定的Unicode字符的代码点值。
      static int compare​(char x, char y)
      数值比较两个 char数值。
      int compareTo​(Character anotherCharacter)
      数字比较两个 Character对象。
      static int digit​(char ch, int radix)
      返回指定基数中的字符 ch的数值。
      static int digit​(int codePoint, int radix)
      返回指定基数中指定字符(Unicode代码点)的数值。
      boolean equals​(Object obj)
      将此对象与指定对象进行比较。
      static char forDigit​(int digit, int radix)
      确定指定基数中特定数字的字符表示。
      static byte getDirectionality​(char ch)
      返回给定字符的Unicode方向属性。
      static byte getDirectionality​(int codePoint)
      返回给定字符的Unicode方向性属性(Unicode代码点)。
      static String getName​(int codePoint)
      返回指定字符 codePoint的Unicode名称,如果代码点为 unassigned ,则返回null。
      static int getNumericValue​(char ch)
      返回指定的Unicode字符表示的值为 int
      static int getNumericValue​(int codePoint)
      返回指定字符(Unicode代码点)表示的值为 int
      static int getType​(char ch)
      返回一个值,表示一个字符的一般类别。
      static int getType​(int codePoint)
      返回一个值,表示一个字符的一般类别。
      int hashCode​()
      返回此Character的哈希码; 等于调用charValue()的结果。
      static int hashCode​(char value)
      返回一个char值的哈希码; 兼容Character.hashCode()
      static char highSurrogate​(int codePoint)
      返回表示UTF-16编码中指定的补充字符(Unicode代码点)的 surrogate pair首字母代理( high surrogate code unit )。
      static boolean isAlphabetic​(int codePoint)
      确定指定的字符(Unicode代码点)是否是字母表。
      static boolean isBmpCodePoint​(int codePoint)
      确定指定字符(Unicode代码点)是否在 Basic Multilingual Plane (BMP)中
      static boolean isDefined​(char ch)
      确定字符是否以Unicode定义。
      static boolean isDefined​(int codePoint)
      确定Unicode中是否定义了一个字符(Unicode代码点)。
      static boolean isDigit​(char ch)
      确定指定的字符是否是数字。
      static boolean isDigit​(int codePoint)
      确定指定的字符(Unicode代码点)是否为数字。
      static boolean isHighSurrogate​(char ch)
      确定给定的 char值是否为 Unicode high-surrogate code unit (也称为 引导代理单元 )。
      static boolean isIdentifierIgnorable​(char ch)
      确定指定的字符是否应被视为Java标识符或Unicode标识符中的可忽略字符。
      static boolean isIdentifierIgnorable​(int codePoint)
      确定指定字符(Unicode代码点)是否应被视为Java标识符或Unicode标识符中的可忽略字符。
      static boolean isIdeographic​(int codePoint)
      确定指定字符(Unicode代码点)是否是Unicode标准定义的CJKV(中文,日文,韩文和越南文)表意文字。
      static boolean isISOControl​(char ch)
      确定指定的字符是否是ISO控制字符。
      static boolean isISOControl​(int codePoint)
      确定引用的字符(Unicode代码点)是否是ISO控制字符。
      static boolean isJavaIdentifierPart​(char ch)
      确定指定的字符是否可以是Java标识符的一部分,而不是第一个字符。
      static boolean isJavaIdentifierPart​(int codePoint)
      确定字符(Unicode代码点)可能是Java标识符的一部分,而不是第一个字符。
      static boolean isJavaIdentifierStart​(char ch)
      确定指定字符是否允许作为Java标识符中的第一个字符。
      static boolean isJavaIdentifierStart​(int codePoint)
      确定字符(Unicode代码点)是否允许作为Java标识符中的第一个字符。
      static boolean isJavaLetter​(char ch)
      已过时。
      替换为isJavaIdentifierStart(char)。
      static boolean isJavaLetterOrDigit​(char ch)
      已过时。
      由isJavaIdentifierPart(char)替代。
      static boolean isLetter​(char ch)
      确定指定的字符是否是一个字母。
      static boolean isLetter​(int codePoint)
      确定指定的字符(Unicode代码点)是否是一个字母。
      static boolean isLetterOrDigit​(char ch)
      确定指定的字符是字母还是数字。
      static boolean isLetterOrDigit​(int codePoint)
      确定指定的字符(Unicode代码点)是字母还是数字。
      static boolean isLowerCase​(char ch)
      确定指定的字符是否是小写字符。
      static boolean isLowerCase​(int codePoint)
      确定指定的字符(Unicode代码点)是否是小写字符。
      static boolean isLowSurrogate​(char ch)
      确定给定的 char值是否为 Unicode low-surrogate code unit (也称为 尾随代理单元 )。
      static boolean isMirrored​(char ch)
      根据Unicode规范确定字符是否镜像。
      static boolean isMirrored​(int codePoint)
      确定是否根据Unicode规范镜像指定的字符(Unicode代码点)。
      static boolean isSpace​(char ch)
      已过时。
      替换为isWhitespace(char)。
      static boolean isSpaceChar​(char ch)
      确定指定的字符是否是Unicode空格字符。
      static boolean isSpaceChar​(int codePoint)
      确定指定字符(Unicode代码点)是否为Unicode空格字符。
      static boolean isSupplementaryCodePoint​(int codePoint)
      确定指定字符(Unicode代码点)是否在 supplementary character范围内。
      static boolean isSurrogate​(char ch)
      确定给定的 char值是否是Unicode 代理代码单元
      static boolean isSurrogatePair​(char high, char low)
      确定指定的一对 char值是否为有效的 Unicode surrogate pair
      static boolean isTitleCase​(char ch)
      确定指定的字符是否是一个titlecase字符。
      static boolean isTitleCase​(int codePoint)
      确定指定的字符(Unicode代码点)是否是一个titlecase字符。
      static boolean isUnicodeIdentifierPart​(char ch)
      确定指定的字符是否可以是Unicode标识符的一部分,而不是第一个字符。
      static boolean isUnicodeIdentifierPart​(int codePoint)
      确定指定的字符(Unicode代码点)是否可能是Unicode标识符的一部分,而不是第一个字符。
      static boolean isUnicodeIdentifierStart​(char ch)
      确定指定字符是否允许为Unicode标识符中的第一个字符。
      static boolean isUnicodeIdentifierStart​(int codePoint)
      确定Unicode标识符中的第一个字符是否允许指定的字符(Unicode代码点)。
      static boolean isUpperCase​(char ch)
      确定指定的字符是否为大写字符。
      static boolean isUpperCase​(int codePoint)
      确定指定的字符(Unicode代码点)是否为大写字符。
      static boolean isValidCodePoint​(int codePoint)
      确定指定的代码点是否有效 Unicode code point value
      static boolean isWhitespace​(char ch)
      根据Java确定指定的字符是否为空格。
      static boolean isWhitespace​(int codePoint)
      根据Java确定指定字符(Unicode代码点)是否为空格。
      static char lowSurrogate​(int codePoint)
      返回表示UTF-16编码中指定的补充字符(Unicode代码点)的 surrogate pair后续代理( low surrogate code unit )。
      static int offsetByCodePoints​(char[] a, int start, int count, int index, int codePointOffset)
      返回给定的 char子阵列中与 indexcodePointOffset代码点偏移的索引。
      static int offsetByCodePoints​(CharSequence seq, int index, int codePointOffset)
      返回给定的char序列中与 indexcodePointOffset代码点偏移的索引。
      static char reverseBytes​(char ch)
      返回通过反转指定的 char值中的字节顺序获得的值。
      static char[] toChars​(int codePoint)
      将指定的字符(Unicode代码点)转换为存储在 char数组中的UTF-16表示形式。
      static int toChars​(int codePoint, char[] dst, int dstIndex)
      将指定的字符(Unicode代码点)转换为其UTF-16表示形式。
      static int toCodePoint​(char high, char low)
      将指定的代理对转换为其补充代码点值。
      static char toLowerCase​(char ch)
      使用UnicodeData文件中的大小写映射信息将字符参数转换为小写。
      static int toLowerCase​(int codePoint)
      使用UnicodeData文件中的大小写映射信息将字符(Unicode代码点)参数转换为小写。
      String toString​()
      返回一个表示 Character的值的 String对象。
      static String toString​(char c)
      返回 String表示指定对象 char
      static char toTitleCase​(char ch)
      使用UnicodeData文件中的案例映射信息将字符参数转换为titlecase。
      static int toTitleCase​(int codePoint)
      使用UnicodeData文件中的案例映射信息将字符(Unicode代码点)参数转换为titlecase。
      static char toUpperCase​(char ch)
      使用UnicodeData文件中的案例映射信息将字符参数转换为大写。
      static int toUpperCase​(int codePoint)
      使用UnicodeData文件中的案例映射信息将字符(Unicode代码点)参数转换为大写。
      static Character valueOf​(char c)
      返回表示 char值的 Character实例。
    • 字段详细信息

      • MIN_VALUE

        public static final char MIN_VALUE
        该字段的常量值是 char '\u0000'
        从以下版本开始:
        1.0.2
        另请参见:
        Constant Field Values
      • MAX_VALUE

        public static final char MAX_VALUE
        该字段的常数值是 char '\uFFFF'
        从以下版本开始:
        1.0.2
        另请参见:
        Constant Field Values
      • TYPE

        public static final Class<Character> TYPE
        Class表示原始类型 char实例。
        从以下版本开始:
        1.1
      • UNASSIGNED

        public static final byte UNASSIGNED
        Unicode规范中的一般类别“Cn”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • UPPERCASE_LETTER

        public static final byte UPPERCASE_LETTER
        Unicode规范中的一般类别“Lu”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • LOWERCASE_LETTER

        public static final byte LOWERCASE_LETTER
        Unicode规范中的一般类别“L1”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • TITLECASE_LETTER

        public static final byte TITLECASE_LETTER
        Unicode规范中的常规类别“Lt”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • MODIFIER_LETTER

        public static final byte MODIFIER_LETTER
        Unicode规范中的一般类别“Lm”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • OTHER_LETTER

        public static final byte OTHER_LETTER
        Unicode规范中的一般类别“Lo”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • NON_SPACING_MARK

        public static final byte NON_SPACING_MARK
        Unicode规范中的一般类别“Mn”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • ENCLOSING_MARK

        public static final byte ENCLOSING_MARK
        Unicode规范中的一般类别“Me”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • COMBINING_SPACING_MARK

        public static final byte COMBINING_SPACING_MARK
        Unicode规范中的一般类别“Mc”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • DECIMAL_DIGIT_NUMBER

        public static final byte DECIMAL_DIGIT_NUMBER
        Unicode规范中的一般类别“Nd”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • LETTER_NUMBER

        public static final byte LETTER_NUMBER
        Unicode规范中的一般类别“Nl”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • OTHER_NUMBER

        public static final byte OTHER_NUMBER
        Unicode规范中的常规类别“否”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • SPACE_SEPARATOR

        public static final byte SPACE_SEPARATOR
        Unicode规范中的一般类别“Zs”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • LINE_SEPARATOR

        public static final byte LINE_SEPARATOR
        Unicode规范中的一般类别“Zl”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • PARAGRAPH_SEPARATOR

        public static final byte PARAGRAPH_SEPARATOR
        Unicode规范中的一般类别“Zp”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • CONTROL

        public static final byte CONTROL
        Unicode规范中的一般类别“Cc”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • FORMAT

        public static final byte FORMAT
        Unicode规范中的一般类别“Cf”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • PRIVATE_USE

        public static final byte PRIVATE_USE
        Unicode规范中的一般类别“Co”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • SURROGATE

        public static final byte SURROGATE
        Unicode规范中的常规类别“Cs”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • DASH_PUNCTUATION

        public static final byte DASH_PUNCTUATION
        Unicode规范中的一般类别“Pd”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • START_PUNCTUATION

        public static final byte START_PUNCTUATION
        Unicode规范中的一般类别“Ps”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • END_PUNCTUATION

        public static final byte END_PUNCTUATION
        Unicode规范中的一般类别“Pe”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • CONNECTOR_PUNCTUATION

        public static final byte CONNECTOR_PUNCTUATION
        Unicode规范中的通用类别“Pc”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • OTHER_PUNCTUATION

        public static final byte OTHER_PUNCTUATION
        Unicode规范中的一般类别“Po”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • MATH_SYMBOL

        public static final byte MATH_SYMBOL
        Unicode规范中的通用类别“Sm”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • CURRENCY_SYMBOL

        public static final byte CURRENCY_SYMBOL
        Unicode规范中的一般类别“Sc”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • MODIFIER_SYMBOL

        public static final byte MODIFIER_SYMBOL
        Unicode规范中的一般类别“Sk”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • OTHER_SYMBOL

        public static final byte OTHER_SYMBOL
        Unicode规范中的一般类别“So”。
        从以下版本开始:
        1.1
        另请参见:
        Constant Field Values
      • INITIAL_QUOTE_PUNCTUATION

        public static final byte INITIAL_QUOTE_PUNCTUATION
        Unicode规范中的一般类别“Pi”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • FINAL_QUOTE_PUNCTUATION

        public static final byte FINAL_QUOTE_PUNCTUATION
        Unicode规范中的一般类别“Pf”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_UNDEFINED

        public static final byte DIRECTIONALITY_UNDEFINED
        未定义的双向字符类型。 未定义的char值在Unicode规范中具有未定义的方向性。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_LEFT_TO_RIGHT

        public static final byte DIRECTIONALITY_LEFT_TO_RIGHT
        Unicode规范中的强双向字符类型“L”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_RIGHT_TO_LEFT

        public static final byte DIRECTIONALITY_RIGHT_TO_LEFT
        Unicode规范中的强双向字符类型“R”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC

        public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
        Unicode规范中的强双向字符类型“AL”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_EUROPEAN_NUMBER

        public static final byte DIRECTIONALITY_EUROPEAN_NUMBER
        Unicode规范中的弱双向字符类型“EN”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR

        public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
        Unicode规范中的双向字符类型为“ES”较弱。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR

        public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
        Unicode规范中的双向字符类型“ET”较弱。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_ARABIC_NUMBER

        public static final byte DIRECTIONALITY_ARABIC_NUMBER
        Unicode规范中的弱双向字符类型“AN”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_COMMON_NUMBER_SEPARATOR

        public static final byte DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
        Unicode规范中的双向字符类型“CS”弱。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_NONSPACING_MARK

        public static final byte DIRECTIONALITY_NONSPACING_MARK
        Unicode规范中的弱双向字符类型“NSM”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_BOUNDARY_NEUTRAL

        public static final byte DIRECTIONALITY_BOUNDARY_NEUTRAL
        Unicode规范中的双向字符类型“BN”弱。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_PARAGRAPH_SEPARATOR

        public static final byte DIRECTIONALITY_PARAGRAPH_SEPARATOR
        Unicode规范中的中立双向字符类型“B”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_SEGMENT_SEPARATOR

        public static final byte DIRECTIONALITY_SEGMENT_SEPARATOR
        Unicode规范中的中立双向字符类型“S”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_WHITESPACE

        public static final byte DIRECTIONALITY_WHITESPACE
        Unicode规范中的中立双向字符类型“WS”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_OTHER_NEUTRALS

        public static final byte DIRECTIONALITY_OTHER_NEUTRALS
        Unicode规范中的中立双向字符类型“ON”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING

        public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
        Unicode规范中的强双向字符类型“LRE”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE

        public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
        Unicode规范中的强双向字符类型“LRO”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING

        public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
        Unicode规范中的强双向字符类型“RLE”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE

        public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
        Unicode规范中的强双向字符类型“RLO”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_POP_DIRECTIONAL_FORMAT

        public static final byte DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
        Unicode规范中的双向字符类型为“PDF”。
        从以下版本开始:
        1.4
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE

        public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE
        Unicode规范中的双向字符类型“LRI”弱。
        从以下版本开始:
        9
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE

        public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE
        Unicode规范中的弱双向字符类型“RLI”。
        从以下版本开始:
        9
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_FIRST_STRONG_ISOLATE

        public static final byte DIRECTIONALITY_FIRST_STRONG_ISOLATE
        Unicode规范中的弱双向字符类型“FSI”。
        从以下版本开始:
        9
        另请参见:
        Constant Field Values
      • DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE

        public static final byte DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE
        Unicode规范中的双向字符类型为“PDI”。
        从以下版本开始:
        9
        另请参见:
        Constant Field Values
      • MAX_LOW_SURROGATE

        public static final char MAX_LOW_SURROGATE
        一个Unicode low-surrogate code unit的最大值在UTF-16编码中,常数为'\uDFFF' 低代数也被称为拖尾代理
        从以下版本开始:
        1.5
        另请参见:
        Constant Field Values
      • MIN_SURROGATE

        public static final char MIN_SURROGATE
        UTF-16编码中的Unicode代理代码单元的最小值,常数为 '\uD800'
        从以下版本开始:
        1.5
        另请参见:
        Constant Field Values
      • MAX_SURROGATE

        public static final char MAX_SURROGATE
        UTF-16编码中的Unicode代理代码单元的最大值,常数为 '\uDFFF'
        从以下版本开始:
        1.5
        另请参见:
        Constant Field Values
      • SIZE

        public static final int SIZE
        用于以无符号二进制形式表示 char值的位数,常数为 16
        从以下版本开始:
        1.5
        另请参见:
        Constant Field Values
      • BYTES

        public static final int BYTES
        用于以无符号二进制形式表示 char值的字节数。
        从以下版本开始:
        1.8
        另请参见:
        Constant Field Values
    • 构造方法详细信息

      • Character

        @Deprecated(since="9")
        public Character​(char value)
        已过时。 很少使用这个构造函数。 静态工厂valueOf(char)通常是一个更好的选择,因为它可能产生明显更好的空间和时间性能。
        构造新分配的 Character对象,该对象表示指定的 char值。
        参数
        value - 要由 Character对象表示的值。
    • 方法详细信息

      • valueOf

        public static Character valueOf​(char c)
        返回表示指定的char值的Character实例。 如果不需要新的Character实例,则该方法通常应优先于构造函数Character(char)使用 ,因为该方法可能通过缓存经常请求的值而产生明显更好的空间和时间性能。 此方法将始终将值范围'\u0000'缓存到'\u007F' (包括该值),并且可能会超出此范围之外的其他值。
        参数
        c - 一个char值。
        结果
        一个代表 cCharacter实例。
        从以下版本开始:
        1.5
      • charValue

        public char charValue​()
        返回此 Character对象的值。
        结果
        由该对象表示的原始值 char
      • hashCode

        public static int hashCode​(char value)
        返回一个char值的哈希码; 兼容Character.hashCode()
        参数
        value - 用于返回哈希码的 char
        结果
        一个哈希码值为 char值。
        从以下版本开始:
        1.8
      • equals

        public boolean equals​(Object obj)
        将此对象与指定对象进行比较。 结果是true当且仅当参数不是null并且是一个Character对象,表示与此对象相同的值为char
        重写:
        equalsObject
        参数
        obj - 要比较的对象。
        结果
        true如果对象是一样的; 否则为false
        另请参见:
        Object.hashCode()HashMap
      • toString

        public String toString​()
        返回一个表示Character的值的String对象。 结果是长度为1的字符串,其唯一组件是由该Character对象表示的基元char值。
        重写:
        toStringObject
        结果
        该对象的字符串表示形式。
      • toString

        public static String toString​(char c)
        返回String表示指定对象char 结果是长度为1的字符串,仅由指定的char
        参数
        c - 要转换的 char
        结果
        指定的字符串表示为 char
        从以下版本开始:
        1.4
      • isValidCodePoint

        public static boolean isValidCodePoint​(int codePoint)
        确定指定的代码点是否有效 Unicode code point value
        参数
        codePoint - 要测试的Unicode代码点
        结果
        true如果指定的代码点值在MIN_CODE_POINTMAX_CODE_POINT之间; 否则为false
        从以下版本开始:
        1.5
      • isBmpCodePoint

        public static boolean isBmpCodePoint​(int codePoint)
        确定指定字符(Unicode代码点)是否在Basic Multilingual Plane (BMP)中 这样的代码点可以使用单个char来表示。
        参数
        codePoint - 要测试的字符(Unicode码点)
        结果
        true如果指定的代码点在MIN_VALUEMAX_VALUE之间; 否则为false
        从以下版本开始:
        1.7
      • isSupplementaryCodePoint

        public static boolean isSupplementaryCodePoint​(int codePoint)
        确定指定字符(Unicode代码点)是否在 supplementary character范围内。
        参数
        codePoint - 要测试的字符(Unicode代码点)
        结果
        true如果指定的代码点在MIN_SUPPLEMENTARY_CODE_POINTMAX_CODE_POINT之间; 否则为false
        从以下版本开始:
        1.5
      • isSurrogatePair

        public static boolean isSurrogatePair​(char high,
                                              char low)
        确定指定的一对char值是否为有效的Unicode surrogate pair

        此方法等效于表达式:

        
         isHighSurrogate(high) && isLowSurrogate(low)
         
        参数
        high - 待测试的高替代代码值
        low - 要测试的低代理代码值
        结果
        true如果指定的高和低代理代码值代表有效的代理对; 否则为false
        从以下版本开始:
        1.5
      • charCount

        public static int charCount​(int codePoint)
        确定代表指定字符(Unicode代码点)所需的char值。 如果指定的字符等于或大于0x10000,则该方法返回2.否则,该方法返回1。

        此方法不会将指定的字符验证为有效的Unicode代码点。 如果需要,来电者必须使用isValidCodePoint验证字符值。

        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        2如果字符是有效的补充字符; 1否则。
        从以下版本开始:
        1.5
        另请参见:
        isSupplementaryCodePoint(int)
      • toCodePoint

        public static int toCodePoint​(char high,
                                      char low)
        将指定的代理对转换为其补充代码点值。 此方法不验证指定的代理对。 如果需要,来电者必须使用isSurrogatePair进行验证。
        参数
        high - 高 high代码单位
        low - 低代码单位
        结果
        由指定代理对组成的补充代码点。
        从以下版本开始:
        1.5
      • codePointAt

        public static int codePointAt​(CharSequence seq,
                                      int index)
        返回CharSequence给定索引处的代码点。 如果char给定索引处的值CharSequence处于高代理项范围,下列指数小于所述长度CharSequencechar以下索引处的值是在低代理项范围内,则所述辅助返回与该替代对对应的代码点。 否则,返回给定索引处的char值。
        参数
        seq - char值的序列(Unicode代码单位)
        index - 要转换的 char值(Unicode码单位)的 seq
        结果
        在指定的索引处的Unicode代码点
        异常
        NullPointerException - 如果 seq为空。
        IndexOutOfBoundsException - 如果值 index为负数或不小于 seq.length()
        从以下版本开始:
        1.5
      • codePointAt

        public static int codePointAt​(char[] a,
                                      int index)
        返回char数组的给定索引处的代码点。 如果char阵列中给定指数的char值处于高替代范围,则以下指数小于char阵列的长度,而下列指标的char值处于低char范围,则返回与该替代对对应的补码。 否则,返回给定索引处的char值。
        参数
        a - char阵列
        index - 要转换的 char数组中的 char值(Unicode代码单位)的 char
        结果
        在指定的索引处的Unicode代码点
        异常
        NullPointerException - 如果 a为空。
        IndexOutOfBoundsException - 如果值 index为负数或不小于 char阵列的长度。
        从以下版本开始:
        1.5
      • codePointAt

        public static int codePointAt​(char[] a,
                                      int index,
                                      int limit)
        返回char数组的给定索引处的代码点,其中只能使用index小于limit数组元素。 如果char阵列中给定指数的char值处于高代理范围内,则以下指数小于limit ,下列指数中的char值处于低代理范围,则补码代码点相应的这个代理对被退回。 否则,返回给定索引处的char值。
        参数
        a - char数组
        index - 要转换的 char数组中的 char值(Unicode代码单位)的 char
        limit - 可以在 char数组中使用的最后一个数组元素后的索引
        结果
        在指定的索引处的Unicode代码点
        异常
        NullPointerException - 如果 a为空。
        IndexOutOfBoundsException - 如果 index参数为负数或不小于 limit参数,或者如果 limit参数为负数或大于 char数组的长度。
        从以下版本开始:
        1.5
      • codePointBefore

        public static int codePointBefore​(CharSequence seq,
                                          int index)
        返回CharSequence给定索引之前的代码点。 如果char在值(index - 1)CharSequence处于低代理项范围, (index - 2)不为负,并且char在值(index - 2)CharSequence处于高代理项范围内,则对应于该代理对的增补代码点是回。 否则,返回(index - 1)char值。
        参数
        seq - CharSequence实例
        index - 应该返回的代码点后面的索引
        结果
        Unicode代码点值在给定索引之前。
        异常
        NullPointerException - 如果 seq为空。
        IndexOutOfBoundsException - 如果 index参数小于1或大于 seq.length()
        从以下版本开始:
        1.5
      • codePointBefore

        public static int codePointBefore​(char[] a,
                                          int index)
        返回char数组的给定索引之前的代码点。 如果char在值(index - 1)char阵列是在低代理项范围, (index - 2)不为负,并且char在值(index - 2)char阵列在高代理项范围内,则对应于该替代的增补代码点对被退回。 否则,返回(index - 1)char值。
        参数
        a - char数组
        index - 应该返回的代码点之后的索引
        结果
        Unicode代码点值在给定索引之前。
        异常
        NullPointerException - 如果 a为空。
        IndexOutOfBoundsException - 如果 index参数小于1或大于 char数组的长度
        从以下版本开始:
        1.5
      • codePointBefore

        public static int codePointBefore​(char[] a,
                                          int index,
                                          int start)
        返回char数组的给定索引之前的代码点,其中只能使用index大于或等于start数组元素。 如果char (index - 1)char阵列的char阵列处于低(index - 2)范围内,则(index - 2)不得低于start ,而char (index - 2)中的charchar阵列中处于高替代范围内,则补码代码点对应这个代理对被退回。 否则,返回(index - 1)char值。
        参数
        a - char数组
        index - 应该返回的代码点后面的索引
        start - char数组中第一个数组元素的 char
        结果
        Unicode代码点值在给定索引之前。
        异常
        NullPointerException - 如果 a为空。
        IndexOutOfBoundsException - 如果 index参数不大于 start参数或大于 char数组的长度,或者如果 start参数为负数或不小于 char数组的长度。
        从以下版本开始:
        1.5
      • toChars

        public static int toChars​(int codePoint,
                                  char[] dst,
                                  int dstIndex)
        将指定的字符(Unicode代码点)转换为其UTF-16表示形式。 如果指定的代码点是BMP(基本多语言平面或平面0)值,则相同的值存储在dst[dstIndex] ,并返回1。 如果指定的代码点是补充字符,则其代理值存储在dst[dstIndex] (高代码)和dst[dstIndex+1] (低代理)中,并返回2。
        参数
        codePoint - 要转换的字符(Unicode代码点)。
        dst -的阵列 char其中 codePoint的UTF-16值被存储。
        dstIndex - 将转换后的值存储到 dst数组中的起始索引。
        结果
        1,如果代码点是BMP代码点,2代码点是补码。
        异常
        IllegalArgumentException - 如果指定的 codePoint不是有效的Unicode代码点。
        NullPointerException - 如果指定的 dst为空。
        IndexOutOfBoundsException - 如果dstIndex为负数或不小于dst.length ,或者如果dst中的dstIndex没有足够的数组元素来存储产生的char值。 (如果dstIndex等于dst.length-1 ,并且指定的codePoint是补充字符,则高代理值不存储在dst[dstIndex] 。)
        从以下版本开始:
        1.5
      • toChars

        public static char[] toChars​(int codePoint)
        将指定的字符(Unicode代码点)转换为存储在char数组中的UTF-16表示形式。 如果指定的代码点是BMP(基本多语言平面或平面0)值,则生成的char数组的值与codePoint相同。 如果指定的代码点是补充代码点,则产生的char阵列具有相应的代理对。
        参数
        codePoint - 一个Unicode代码点
        结果
        一个具有 codePoint的UTF-16表示的 char阵列。
        异常
        IllegalArgumentException - 如果指定的 codePoint不是有效的Unicode代码点。
        从以下版本开始:
        1.5
      • codePointCount

        public static int codePointCount​(CharSequence seq,
                                         int beginIndex,
                                         int endIndex)
        返回指定字符序列的文本范围内的Unicode代码点数。 文本范围从指定的beginIndex开始,并扩展到char ,索引号为endIndex - 1 因此,文本范围的长度( char s)为endIndex-beginIndex 文本范围内的非配对替代品,每一个代码点都是一样的。
        参数
        seq - 字符序列
        beginIndex - 索引到第一个 char的文本范围。
        endIndex - 索引在最后一个 char的文本范围之后。
        结果
        指定文本范围内的Unicode代码点数
        异常
        NullPointerException - 如果 seq为空。
        IndexOutOfBoundsException - 如果 beginIndex为负数,或 endIndex大于给定序列的长度,或者 beginIndex大于 endIndex
        从以下版本开始:
        1.5
      • codePointCount

        public static int codePointCount​(char[] a,
                                         int offset,
                                         int count)
        返回char数组参数的子阵列中的Unicode代码点数。 offset参数是子阵列的第一个char的索引,而count参数指定了char s char阵列的长度。 子代码中的非配对代理计数为每个代码点。
        参数
        a - char数组
        offset - 在给定的 char数组中的第一个 char的指数
        count - 子阵列的长度在 char s
        结果
        指定子阵列中的Unicode代码点数
        异常
        NullPointerException - 如果 a为空。
        IndexOutOfBoundsException - 如果 offsetcount为负数,或者如果 offset + count大于给定数组的长度。
        从以下版本开始:
        1.5
      • offsetByCodePoints

        public static int offsetByCodePoints​(CharSequence seq,
                                             int index,
                                             int codePointOffset)
        返回给定char序列中的索引,该索引与给定的indexcodePointOffset代码点偏移。 indexcodePointOffset给出的文本范围内的非配对替代品作为一个代码点。
        参数
        seq - 字符序列
        index - 要偏移的索引
        codePointOffset - 代码点的偏移量
        结果
        char序列中的索引
        异常
        NullPointerException - 如果 seq为空。
        IndexOutOfBoundsException - 如果 index为负或大于char序列的长度,或者如果 codePointOffset为正,并且从 index开始的子 index具有少于 codePointOffset码点,或者如果 codePointOffset为负,并且 index之前的子 index小于绝对值的 codePointOffset代码点。
        从以下版本开始:
        1.5
      • offsetByCodePoints

        public static int offsetByCodePoints​(char[] a,
                                             int start,
                                             int count,
                                             int index,
                                             int codePointOffset)
        返回给定的char子阵列中的索引,该子阵列与给定的indexcodePointOffset代码点偏移。 startcount参数指定char数组的子阵列。 indexcodePointOffset给出的文本范围内的非配对替代品每个作为一个代码点。
        参数
        a - char数组
        start - 该子阵列第一个 char的索引
        count - 子阵列的长度在 char s
        index - 要偏移的索引
        codePointOffset - 代码点的偏移量
        结果
        子阵列中的索引
        异常
        NullPointerException - 如果 a为空。
        IndexOutOfBoundsException -如果 startcount是否定的,或者如果 start + count大于给定阵列的长度大,或如果 index小于 start更大或然后 start + count ,或者如果 codePointOffset为正和文本范围开始 index ,结束时用 start + count - 1有少于 codePointOffset代码点,或者如果 codePointOffset为负且文本范围开始 start ,结束时用 index - 1具有比的绝对值较少 codePointOffset代码点。
        从以下版本开始:
        1.5
      • isLowerCase

        public static boolean isLowerCase​(char ch)
        确定指定的字符是否是小写字符。

        如果由Character.getType(ch)提供的一般类别类型为LOWERCASE_LETTER ,或者符合Unicode标准定义的其他Character.getType(ch) ,则字符为小写。

        以下是小写字符的示例:

         a b c d e f g h i j k l m n o p q r s t u v w x y z
         '\u00DF' '\u00E0' '\u00E1' '\u00E2' '\u00E3' '\u00E4' '\u00E5' '\u00E6'
         '\u00E7' '\u00E8' '\u00E9' '\u00EA' '\u00EB' '\u00EC' '\u00ED' '\u00EE'
         '\u00EF' '\u00F0' '\u00F1' '\u00F2' '\u00F3' '\u00F4' '\u00F5' '\u00F6'
         '\u00F8' '\u00F9' '\u00FA' '\u00FB' '\u00FC' '\u00FD' '\u00FE' '\u00FF'
         

        许多其他Unicode字符也是小写的。

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符(包括补充字符),请使用isLowerCase(int)方法。

        参数
        ch - 要测试的字符。
        结果
        true如果字符是小写的; 否则为false
        另请参见:
        isLowerCase(char)isTitleCase(char)toLowerCase(char)getType(char)
      • isLowerCase

        public static boolean isLowerCase​(int codePoint)
        确定指定的字符(Unicode代码点)是否是小写字符。

        如果由getType(codePoint)提供的一般类别类型是LOWERCASE_LETTER ,或者它具有由Unicode标准定义的贡献属性Other_Lowercase,那么一个字符是小写的。

        以下是小写字符的示例:

         a b c d e f g h i j k l m n o p q r s t u v w x y z
         '\u00DF' '\u00E0' '\u00E1' '\u00E2' '\u00E3' '\u00E4' '\u00E5' '\u00E6'
         '\u00E7' '\u00E8' '\u00E9' '\u00EA' '\u00EB' '\u00EC' '\u00ED' '\u00EE'
         '\u00EF' '\u00F0' '\u00F1' '\u00F2' '\u00F3' '\u00F4' '\u00F5' '\u00F6'
         '\u00F8' '\u00F9' '\u00FA' '\u00FB' '\u00FC' '\u00FD' '\u00FE' '\u00FF'
         

        许多其他Unicode字符也是小写的。

        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        true如果字符是小写的; 否则为false
        从以下版本开始:
        1.5
        另请参见:
        isLowerCase(int)isTitleCase(int)toLowerCase(int)getType(int)
      • isUpperCase

        public static boolean isUpperCase​(char ch)
        确定指定的字符是否为大写字符。

        如果其一般类别类型由Character.getType(ch)提供,则字符为大写,为UPPERCASE_LETTER 或者它具有由Unicode标准定义的贡献属性Other_Uppercase。

        以下是大写字符的示例:

         A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
         '\u00C0' '\u00C1' '\u00C2' '\u00C3' '\u00C4' '\u00C5' '\u00C6' '\u00C7'
         '\u00C8' '\u00C9' '\u00CA' '\u00CB' '\u00CC' '\u00CD' '\u00CE' '\u00CF'
         '\u00D0' '\u00D1' '\u00D2' '\u00D3' '\u00D4' '\u00D5' '\u00D6' '\u00D8'
         '\u00D9' '\u00DA' '\u00DB' '\u00DC' '\u00DD' '\u00DE'
         

        许多其他Unicode字符也是大写字母。

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符,包括补充字符,请使用isUpperCase(int)方法。

        参数
        ch - 要测试的字符。
        结果
        true如果字符是大写字母; false否则。
        从以下版本开始:
        1.0
        另请参见:
        isLowerCase(char)isTitleCase(char)toUpperCase(char)getType(char)
      • isUpperCase

        public static boolean isUpperCase​(int codePoint)
        确定指定的字符(Unicode代码点)是否为大写字符。

        如果由getType(codePoint)提供的一般类别类型是UPPERCASE_LETTER ,或者它具有由Unicode标准定义的贡献属性Other_Uppercase,那么一个字符是大写的。

        以下是大写字符的示例:

         A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
         '\u00C0' '\u00C1' '\u00C2' '\u00C3' '\u00C4' '\u00C5' '\u00C6' '\u00C7'
         '\u00C8' '\u00C9' '\u00CA' '\u00CB' '\u00CC' '\u00CD' '\u00CE' '\u00CF'
         '\u00D0' '\u00D1' '\u00D2' '\u00D3' '\u00D4' '\u00D5' '\u00D6' '\u00D8'
         '\u00D9' '\u00DA' '\u00DB' '\u00DC' '\u00DD' '\u00DE'
         

        许多其他Unicode字符也是大写字母。

        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        true如果字符是大写字母; 否则为false
        从以下版本开始:
        1.5
        另请参见:
        isLowerCase(int)isTitleCase(int)toUpperCase(int)getType(int)
      • isTitleCase

        public static boolean isTitleCase​(char ch)
        确定指定的字符是否是一个titlecase字符。

        如果其一般类别类型由Character.getType(ch)提供,则字符为titlecase字符,为TITLECASE_LETTER

        一些字符看起来像拉丁字母对。 例如,有一个大写字母,看起来像“LJ”,并有相应的小写字母,看起来像“lj”。 看起来像“Lj”的第三种形式是使用初始大写字母小写的单词时使用的适当形式,如书名。

        这些是这个方法返回的一些Unicode字符true

        • LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON
        • LATIN CAPITAL LETTER L WITH SMALL LETTER J
        • LATIN CAPITAL LETTER N WITH SMALL LETTER J
        • LATIN CAPITAL LETTER D WITH SMALL LETTER Z

        许多其他Unicode字符也是titlecase。

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符(包括补充字符),请使用isTitleCase(int)方法。

        参数
        ch - 要测试的字符。
        结果
        true如果字符是titlecase; 否则为false
        从以下版本开始:
        1.0.2
        另请参见:
        isLowerCase(char)isUpperCase(char)toTitleCase(char)getType(char)
      • isTitleCase

        public static boolean isTitleCase​(int codePoint)
        确定指定的字符(Unicode代码点)是否是一个titlecase字符。

        如果其一般类别类型由getType(codePoint)提供,则字符为titlecase字符,为TITLECASE_LETTER

        一些字符看起来像拉丁字母对。 例如,有一个大写字母,看起来像“LJ”,并有相应的小写字母,看起来像“lj”。 看起来像“Lj”的第三种形式是使用初始大写字母小写的单词时使用的适当形式,如书名。

        这些是这个方法返回的一些Unicode字符true

        • LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON
        • LATIN CAPITAL LETTER L WITH SMALL LETTER J
        • LATIN CAPITAL LETTER N WITH SMALL LETTER J
        • LATIN CAPITAL LETTER D WITH SMALL LETTER Z

        许多其他Unicode字符也是titlecase。

        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        true如果字符是titlecase; 否则为false
        从以下版本开始:
        1.5
        另请参见:
        isLowerCase(int)isUpperCase(int)toTitleCase(int)getType(int)
      • isDigit

        public static boolean isDigit​(char ch)
        确定指定的字符是否是数字。

        如果其一般类别类型由Character.getType(ch)提供,则字符为数字,为DECIMAL_DIGIT_NUMBER

        一些包含数字的Unicode字符范围:

        • '\u0030''\u0039' ,ISO-LATIN-1位数字( '0''9'
        • '\u0660''\u0669' ,阿拉伯语 - 印度数字
        • '\u06F0''\u06F9' ,扩展阿拉伯语 - 印度数字
        • '\u0966'通过'\u096F' ,梵文数字
        • '\uFF10''\uFF19' ,全宽数字
        许多其他字符范围也包含数字。

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符,包括补充字符,请使用isDigit(int)方法。

        参数
        ch - 要测试的字符。
        结果
        true如果字符是数字; 否则为false
        另请参见:
        digit(char, int)forDigit(int, int)getType(char)
      • isDigit

        public static boolean isDigit​(int codePoint)
        确定指定的字符(Unicode代码点)是否为数字。

        如果其一般类别类型由getType(codePoint)提供, 则为字符数字,为DECIMAL_DIGIT_NUMBER

        一些包含数字的Unicode字符范围:

        • '\u0030''\u0039' ,ISO-LATIN-1位数字( '0''9'
        • '\u0660''\u0669' ,阿拉伯语 - 印度数字
        • '\u06F0''\u06F9' ,扩展阿拉伯语 - 印度数字
        • '\u0966''\u096F' ,梵文数字
        • '\uFF10'通过'\uFF19' ,全宽数字
        许多其他字符范围也包含数字。
        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        true如果字符是数字; 否则为false
        从以下版本开始:
        1.5
        另请参见:
        forDigit(int, int)getType(int)
      • isDefined

        public static boolean isDefined​(char ch)
        确定字符是否以Unicode定义。

        如果至少有以下条件之一成立,则定义一个字符:

        • 它在UnicodeData文件中有一个条目。
        • 它具有由UnicodeData文件定义的范围内的值。

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符(包括补充字符),请使用isDefined(int)方法。

        参数
        ch - 要测试的字符
        结果
        如果字符在Unicode中具有定义的含义, true ; 否则为false
        从以下版本开始:
        1.0.2
        另请参见:
        isDigit(char)isLetter(char)isLetterOrDigit(char)isLowerCase(char)isTitleCase(char)isUpperCase(char)
      • isDefined

        public static boolean isDefined​(int codePoint)
        确定Unicode中是否定义了一个字符(Unicode代码点)。

        如果至少有以下条件之一成立,则定义一个字符:

        • 它在UnicodeData文件中有一个条目。
        • 它具有由UnicodeData文件定义的范围内的值。
        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        如果字符在Unicode中具有定义的含义, true ; 否则为false
        从以下版本开始:
        1.5
        另请参见:
        isDigit(int)isLetter(int)isLetterOrDigit(int)isLowerCase(int)isTitleCase(int)isUpperCase(int)
      • isLetter

        public static boolean isLetter​(int codePoint)
        确定指定的字符(Unicode代码点)是否是一个字母。

        如果由getType(codePoint)提供的一般类别类型是以下任何一种,则字符被视为信件:

        • UPPERCASE_LETTER
        • LOWERCASE_LETTER
        • TITLECASE_LETTER
        • MODIFIER_LETTER
        • OTHER_LETTER
        不是所有的信都有情况。 许多人物都是字母,但既不是大写也不是小写字母,也不是titlecase。
        参数
        codePoint - 要测试的字符(Unicode码点)。
        结果
        true如果字符是一个字母; 否则为false
        从以下版本开始:
        1.5
        另请参见:
        isDigit(int)isJavaIdentifierStart(int)isLetterOrDigit(int)isLowerCase(int)isTitleCase(int)isUnicodeIdentifierStart(int)isUpperCase(int)
      • isJavaLetterOrDigit

        @Deprecated(since="1.1")
        public static boolean isJavaLetterOrDigit​(char ch)
        已过时。 由isJavaIdentifierPart(char)替代。
        确定指定的字符是否可以是Java标识符的一部分,而不是第一个字符。

        当且仅当以下任何一项为真时,字符可能是Java标识符的一部分:

        • 这是一封信
        • 它是货币符号(如'$'
        • 它是一个连接的标点符号(如'_'
        • 它是一个数字
        • 它是一个数字字母(如罗马数字字符)
        • 它是一个组合标记
        • 它是一个非间距标记
        • isIdentifierIgnorable返回true的字符。
        参数
        ch - 要测试的字符。
        结果
        true如果字符可能是Java标识符的一部分; 否则为false
        从以下版本开始:
        1.0.2
        另请参见:
        isJavaLetter(char)isJavaIdentifierStart(char)isJavaIdentifierPart(char)isLetter(char)isLetterOrDigit(char)isUnicodeIdentifierPart(char)isIdentifierIgnorable(char)
      • isAlphabetic

        public static boolean isAlphabetic​(int codePoint)
        确定指定的字符(Unicode代码点)是否是字母表。

        如果由getType(codePoint)提供的一般类别类型是以下任何一种,则字符被视为字母:

        • UPPERCASE_LETTER
        • LOWERCASE_LETTER
        • TITLECASE_LETTER
        • MODIFIER_LETTER
        • OTHER_LETTER
        • LETTER_NUMBER
        或者它具有由Unicode标准定义的Other_Alphabetic的贡献属性。
        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        true如果字符是Unicode字母字符,否则为 false
        从以下版本开始:
        1.7
      • isIdeographic

        public static boolean isIdeographic​(int codePoint)
        确定指定字符(Unicode代码点)是否是Unicode标准定义的CJKV(中文,日文,韩文和越南文)表意文字。
        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        true如果字符是Unicode表意文字字符,否则为 false
        从以下版本开始:
        1.7
      • isJavaIdentifierStart

        public static boolean isJavaIdentifierStart​(int codePoint)
        确定字符(Unicode代码点)是否允许作为Java标识符中的第一个字符。

        当且仅当以下条件之一为真时,字符可能启动Java标识符:

        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        true如果字符可能启动Java标识符; 否则为false
        从以下版本开始:
        1.5
        另请参见:
        isJavaIdentifierPart(int)isLetter(int)isUnicodeIdentifierStart(int)SourceVersion.isIdentifier(CharSequence)
      • isJavaIdentifierPart

        public static boolean isJavaIdentifierPart​(char ch)
        确定指定的字符是否可以是Java标识符的一部分,而不是第一个字符。

        如果以下任何一项为真,则字符可能是Java标识符的一部分:

        • 这是一封信
        • 它是货币符号(如'$'
        • 它是一个连接的标点符号(如'_'
        • 它是一个数字
        • 它是一个数字字母(如罗马数字字符)
        • 它是一个组合标记
        • 它是一个非间距标记
        • isIdentifierIgnorable回报true的字符

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符,包括补充字符,请使用isJavaIdentifierPart(int)方法。

        参数
        ch - 要测试的字符。
        结果
        true如果该字符可能是Java标识符的一部分; 否则为false
        从以下版本开始:
        1.1
        另请参见:
        isIdentifierIgnorable(char)isJavaIdentifierStart(char)isLetterOrDigit(char)isUnicodeIdentifierPart(char)SourceVersion.isIdentifier(CharSequence)
      • isJavaIdentifierPart

        public static boolean isJavaIdentifierPart​(int codePoint)
        确定字符(Unicode代码点)可能是Java标识符的一部分,而不是第一个字符。

        如果以下任何一项为真,则字符可能是Java标识符的一部分:

        • 这是一封信
        • 它是货币符号(如'$'
        • 它是一个连接的标点符号(如'_'
        • 它是一个数字
        • 它是一个数字字母(如罗马数字字符)
        • 它是一个组合标记
        • 它是一个非间距标记
        • isIdentifierIgnorable(codePoint)返回true的字符
        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        true如果该字符可能是Java标识符的一部分; 否则为false
        从以下版本开始:
        1.5
        另请参见:
        isIdentifierIgnorable(int)isJavaIdentifierStart(int)isLetterOrDigit(int)isUnicodeIdentifierPart(int)SourceVersion.isIdentifier(CharSequence)
      • isUnicodeIdentifierStart

        public static boolean isUnicodeIdentifierStart​(int codePoint)
        确定Unicode标识符中的第一个字符是否允许指定的字符(Unicode代码点)。

        如果且仅当以下条件之一为真时,字符可能会启动Unicode标识符:

        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        true如果字符可能启动Unicode标识符; 否则为false
        从以下版本开始:
        1.5
        另请参见:
        isJavaIdentifierStart(int)isLetter(int)isUnicodeIdentifierPart(int)
      • isUnicodeIdentifierPart

        public static boolean isUnicodeIdentifierPart​(char ch)
        确定指定的字符是否可以是Unicode标识符的一部分,而不是第一个字符。

        当且仅当以下语句之一为真时,字符可能是Unicode标识符的一部分:

        • 这是一封信
        • 它是一个连接的标点符号(如'_'
        • 它是一个数字
        • 它是一个数字字母(如罗马数字字符)
        • 它是一个组合标记
        • 它是一个非间距标记
        • isIdentifierIgnorable为这个字符返回true

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符(包括补充字符),请使用isUnicodeIdentifierPart(int)方法。

        参数
        ch - 要测试的字符。
        结果
        true如果字符可能是Unicode标识符的一部分; 否则为false
        从以下版本开始:
        1.1
        另请参见:
        isIdentifierIgnorable(char)isJavaIdentifierPart(char)isLetterOrDigit(char)isUnicodeIdentifierStart(char)
      • isUnicodeIdentifierPart

        public static boolean isUnicodeIdentifierPart​(int codePoint)
        确定指定的字符(Unicode代码点)是否可能是Unicode标识符的一部分,而不是第一个字符。

        当且仅当以下语句之一为真时,字符可能是Unicode标识符的一部分:

        • 这是一封信
        • 它是一个连接的标点符号(如'_'
        • 它是一个数字
        • 它是一个数字字母(如罗马数字字符)
        • 它是一个组合标记
        • 它是一个非间距标记
        • isIdentifierIgnorable为这个字符返回true
        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        true如果字符可能是Unicode标识符的一部分; 否则为false
        从以下版本开始:
        1.5
        另请参见:
        isIdentifierIgnorable(int)isJavaIdentifierPart(int)isLetterOrDigit(int)isUnicodeIdentifierStart(int)
      • isIdentifierIgnorable

        public static boolean isIdentifierIgnorable​(char ch)
        确定指定的字符是否应被视为Java标识符或Unicode标识符中的可忽略字符。

        以下Unicode字符在Java标识符或Unicode标识符中是可忽略的:

        • 不是空格的ISO控制字符
          • '\u0000'通过'\u0008'
          • '\u000E''\u001B'
          • '\u007F''\u009F'
        • 所有字符都具有FORMAT一般类别值

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符,包括补充字符,请使用isIdentifierIgnorable(int)方法。

        参数
        ch - 要测试的字符。
        结果
        true如果字符是可能是Java或Unicode标识符的一部分的可忽略的控制字符; 否则为false
        从以下版本开始:
        1.1
        另请参见:
        isJavaIdentifierPart(char)isUnicodeIdentifierPart(char)
      • isIdentifierIgnorable

        public static boolean isIdentifierIgnorable​(int codePoint)
        确定指定字符(Unicode代码点)是否应被视为Java标识符或Unicode标识符中的可忽略字符。

        以下Unicode字符在Java标识符或Unicode标识符中是可忽略的:

        • 不是空格的ISO控制字符
          • '\u0000''\u0008'
          • '\u000E''\u001B'
          • '\u007F''\u009F'
        • 所有字符都具有FORMAT一般类别值
        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        true如果字符是可能是Java或Unicode标识符的一部分的可忽略的控制字符; 否则为false
        从以下版本开始:
        1.5
        另请参见:
        isJavaIdentifierPart(int)isUnicodeIdentifierPart(int)
      • toLowerCase

        public static char toLowerCase​(char ch)
        使用UnicodeData文件中的大小写映射信息将字符参数转换为小写。

        请注意, Character.isLowerCase(Character.toLowerCase(ch))并不总是为某些字符范围返回true ,特别是那些符号或表意文字。

        一般来说, String.toLowerCase()应该用来将字符映射成小写。 String案例映射方法比Character案例映射方法有好几个好处。 String案例映射方法可以执行区域设置敏感的映射,上下文相关映射和1:M字符映射,而Character案例映射方法不能。

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符(包括补充字符),请使用toLowerCase(int)方法。

        参数
        ch - 要转换的字符。
        结果
        字符的小写等价物(如果有的话) 否则,字符本身。
        另请参见:
        isLowerCase(char)String.toLowerCase()
      • toLowerCase

        public static int toLowerCase​(int codePoint)
        使用UnicodeData文件中的大小写映射信息将字符(Unicode代码点)参数转换为小写。

        请注意, Character.isLowerCase(Character.toLowerCase(codePoint))并不总是为某些字符范围返回true ,特别是那些符号或表意文字。

        一般来说, String.toLowerCase()应该用来将字符映射成小写。 String案例映射方法比Character案例映射方法有好几个好处。 String案例映射方法可以执行区域设置敏感的映射,上下文相关的映射和1:M字符映射,而Character案例映射方法不能。

        参数
        codePoint - 要转换的字符(Unicode代码点)。
        结果
        字符的小写等价物(Unicode代码点),如果有的话; 否则,字符本身。
        从以下版本开始:
        1.5
        另请参见:
        isLowerCase(int)String.toLowerCase()
      • toUpperCase

        public static char toUpperCase​(char ch)
        使用UnicodeData文件中的案例映射信息将字符参数转换为大写。

        请注意, Character.isUpperCase(Character.toUpperCase(ch))并不总是为某些字符范围返回true ,特别是那些符号或表意文字。

        一般来说, String.toUpperCase()应该用于将字符映射到大写。 String案例映射方法比Character案例映射方法有好几个好处。 String案例映射方法可以执行区域设置敏感映射,上下文敏感映射和1:M字符映射,而Character案例映射方法不能。

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符(包括补充字符),请使用toUpperCase(int)方法。

        参数
        ch - 要转换的字符。
        结果
        字符的大写字母(如果有的话) 否则,字符本身。
        另请参见:
        isUpperCase(char)String.toUpperCase()
      • toUpperCase

        public static int toUpperCase​(int codePoint)
        使用UnicodeData文件中的案例映射信息将字符(Unicode代码点)参数转换为大写。

        请注意, Character.isUpperCase(Character.toUpperCase(codePoint))并不总是为某些字符范围返回true ,特别是那些符号或表意文字。

        一般来说, String.toUpperCase()应该用来将字符映射成大写。 String案例映射方法比Character案例映射方法有好几个好处。 String案例映射方法可以执行区域设置敏感映射,上下文相关映射和1:M字符映射,而Character案例映射方法不能。

        参数
        codePoint - 要转换的字符(Unicode代码点)。
        结果
        字符的大写字母(如果有的话) 否则,字符本身。
        从以下版本开始:
        1.5
        另请参见:
        isUpperCase(int)String.toUpperCase()
      • toTitleCase

        public static char toTitleCase​(char ch)
        使用UnicodeData文件中的案例映射信息将字符参数转换为titlecase。 如果一个字符没有明确的titlecase映射,并且本身不是根据UnicodeData的titlecase char,则大写映射作为等效的titlecase映射返回。 如果char参数已经是一个titlecase char ,相同的char值将被返回。

        请注意, Character.isTitleCase(Character.toTitleCase(ch))并不总是为某些范围的字符返回true

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符,包括补充字符,请使用toTitleCase(int)方法。

        参数
        ch - 要转换的字符。
        结果
        如果有的话,相当于这个字符的titlecase; 否则,字符本身。
        从以下版本开始:
        1.0.2
        另请参见:
        isTitleCase(char)toLowerCase(char)toUpperCase(char)
      • toTitleCase

        public static int toTitleCase​(int codePoint)
        使用UnicodeData文件中的案例映射信息将字符(Unicode代码点)参数转换为titlecase。 如果一个字符没有明确的titlecase映射,并且本身不是根据UnicodeData的titlecase char,则大写映射作为等效的titlecase映射返回。 如果字符参数已经是一个titlecase字符,则返回相同的字符值。

        请注意, Character.isTitleCase(Character.toTitleCase(codePoint))并不总是为某些字符范围返回true

        参数
        codePoint - 要转换的字符(Unicode代码点)。
        结果
        如果有的话,相当于这个字符的titlecase; 否则,字符本身。
        从以下版本开始:
        1.5
        另请参见:
        isTitleCase(int)toLowerCase(int)toUpperCase(int)
      • digit

        public static int digit​(char ch,
                                int radix)
        返回指定基数中的字符ch的数值。

        如果基数不在范围MIN_RADIX ≤ radix ≤ MAX_RADIX或者价值ch不是指定基数的有效数字, -1返回。 如果以下至少一项为真,则字符为有效数字:

        • 方法isDigit是字符的true ,字符(或其单字符分解)的Unicode十进制数字值小于指定的基数。 在这种情况下,返回十进制数值。
        • 该字符是大写拉丁字母'A''Z' ,其代码小于radix + 'A' - 10 在这种情况下,返回ch - 'A' + 10
        • 该字符是小写拉丁字母'a''z' ,其代码小于radix + 'a' - 10 在这种情况下,返回ch - 'a' + 10
        • 该字符是通过Z( '\uFF3A' )的全'\uFF21'写拉丁字母A( '\uFF21''\uFF3A' ,其代码小于radix + '\uFF21' - 10 在这种情况下,返回ch - '\uFF21' + 10
        • 该字符是通过z( '\uFF5A' )的全宽小写拉丁字母a( '\uFF41''\uFF5A' ,其代码小于radix + '\uFF41' - 10 在这种情况下,返回ch - '\uFF41' + 10

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符(包括补充字符),请使用digit(int, int)方法。

        参数
        ch - 要转换的字符。
        radix - 基数。
        结果
        由指定基数中的字符表示的数值。
        另请参见:
        forDigit(int, int)isDigit(char)
      • digit

        public static int digit​(int codePoint,
                                int radix)
        返回指定基数中指定字符(Unicode代码点)的数值。

        如果基数不在范围MIN_RADIX ≤ radix ≤ MAX_RADIX ,或者如果字符不是指定基数的有效数字, -1返回。 如果以下至少一项为真,则字符为有效数字:

        • 方法isDigit(codePoint)是字符的true ,字符(或其单字符分解)的Unicode十进制数字值小于指定的基数。 在这种情况下,返回十进制数值。
        • 该字符是大写拉丁字母'A''Z' ,其代码小于radix + 'A' - 10 在这种情况下,返回codePoint - 'A' + 10
        • 该字符是小写拉丁字母'a''z' ,其代码小于radix + 'a' - 10 在这种情况下,返回codePoint - 'a' + 10
        • 该字符是通过Z( '\uFF3A' )的全'\uFF21'写拉丁字母A( '\uFF21''\uFF3A' ,其代码小于radix + '\uFF21' - 10 在这种情况下,返回codePoint - '\uFF21' + 10
        • 字符是通过z( '\uFF5A' )的全宽小写拉丁字母a( '\uFF41''\uFF5A' ,其代码小于radix + '\uFF41'- 10 在这种情况下,返回codePoint - '\uFF41' + 10
        参数
        codePoint - 要转换的字符(Unicode代码点)。
        radix - 基数。
        结果
        由指定基数中的字符表示的数值。
        从以下版本开始:
        1.5
        另请参见:
        forDigit(int, int)isDigit(int)
      • getNumericValue

        public static int getNumericValue​(char ch)
        返回指定的Unicode字符代表的值为int 例如,字符'\u216C' (罗马数字50)将返回一个值为50的int。

        大写字母( '\u0041''\u005A' ),小写字母( '\u0061''\u007A' )和全宽变体( '\uFF21''\uFF3A''\uFF41''\uFF5A' )中的字母AZ具有10至35的数值。这与Unicode规范无关,其中不为这些char值分配数值。

        如果字符没有数值,则返回-1。 如果字符的数值不能表示为非负整数(例如,小数值),则返回-2。

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符,包括补充字符,请使用getNumericValue(int)方法。

        参数
        ch - 要转换的字符。
        结果
        字符的数值,作为非负值int值; -2如果字符具有数值,但该值不能表示为非负值int值; -1,如果字符没有数值。
        从以下版本开始:
        1.1
        另请参见:
        forDigit(int, int)isDigit(char)
      • getNumericValue

        public static int getNumericValue​(int codePoint)
        返回指定字符(Unicode代码点)表示的值为int 例如,字符'\u216C' (罗马数字五十)将返回值为50的int

        大写字母( '\u0041''\u005A' ),小写( '\u0061''\u007A' )以及全宽变体( '\uFF21''\uFF3A''\uFF41''\uFF5A' )的字母AZ都具有从10到35的数值。这与Unicode规范无关,其中不为这些char值分配数值。

        如果字符没有数值,则返回-1。 如果字符的数值不能表示为非负整数(例如,小数值),则返回-2。

        参数
        codePoint - 要转换的字符(Unicode代码点)。
        结果
        字符的数值,作为非负值int值; -2如果字符具有数值,但该值不能表示为非负int值; -1,如果字符没有数值。
        从以下版本开始:
        1.5
        另请参见:
        forDigit(int, int)isDigit(int)
      • isSpace

        @Deprecated(since="1.1")
        public static boolean isSpace​(char ch)
        已过时。 替换为isWhitespace(char)。
        确定指定的字符是否为ISO-LATIN-1空格。 此方法仅返回true以下五个字符: truechars '\t' U+0009 HORIZONTAL TABULATION '\n' U+000A NEW LINE '\f' U+000C FORM FEED '\r' U+000D CARRIAGE RETURN ' ' U+0020 SPACE
        参数
        ch - 要测试的字符。
        结果
        true如果字符是ISO-LATIN-1空格; false否则。
        另请参见:
        isSpaceChar(char)isWhitespace(char)
      • isSpaceChar

        public static boolean isSpaceChar​(char ch)
        确定指定的字符是否是Unicode空格字符。 当且仅当Unicode标准被指定为空格字符时,才将该字符视为空格字符。 如果字符的一般类别类型是以下任何一种,则此方法返回true:
        • SPACE_SEPARATOR
        • LINE_SEPARATOR
        • PARAGRAPH_SEPARATOR

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符,包括补充字符,请使用isSpaceChar(int)方法。

        参数
        ch - 要测试的字符。
        结果
        true如果字符是空格字符; 否则为false
        从以下版本开始:
        1.1
        另请参见:
        isWhitespace(char)
      • isSpaceChar

        public static boolean isSpaceChar​(int codePoint)
        确定指定字符(Unicode代码点)是否为Unicode空格字符。 当且仅当Unicode标准被指定为空格字符时,才将该字符视为空格字符。 如果字符的一般类别类型是以下任何一种,则此方法返回true:
        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        true如果字符是空格字符; 否则为false
        从以下版本开始:
        1.5
        另请参见:
        isWhitespace(int)
      • isWhitespace

        public static boolean isWhitespace​(char ch)
        根据Java确定指定的字符是否为空格。 当且仅当满足以下条件之一时,字符是Java空格字符:
        • 它是Unicode空格字符( SPACE_SEPARATORLINE_SEPARATOR ,或PARAGRAPH_SEPARATOR ),但不也是非打破空间( '\u00A0''\u2007''\u202F' )。
        • '\t' ,U + 0009水平仪。
        • '\n' ,U + 000A LINE FEED。
        • '\u000B' ,U + 000B垂直式。
        • '\f' ,U + 000C FORM FEED。
        • '\r' ,U + 000D '\r' RETURN。
        • '\u001C' ,U + 001C文件分离器。
        • '\u001D' ,U + 001D GROUP '\u001D'
        • '\u001E' ,U + 001E RECORD分隔器。
        • '\u001F' ,U + 001F UNIT SEPARATOR。

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符(包括补充字符),请使用isWhitespace(int)方法。

        参数
        ch - 要测试的字符。
        结果
        true如果字符是Java空格字符; 否则为false
        从以下版本开始:
        1.1
        另请参见:
        isSpaceChar(char)
      • isWhitespace

        public static boolean isWhitespace​(int codePoint)
        根据Java确定指定字符(Unicode代码点)是否为空格。 当且仅当满足以下条件之一时,字符是Java空格字符:
        • 它是Unicode空格字符( SPACE_SEPARATORLINE_SEPARATOR ,或PARAGRAPH_SEPARATOR ),但不也是非打破空间( '\u00A0''\u2007''\u202F' )。
        • '\t' ,U + 0009水平仪。
        • '\n' ,U + 000A LINE FEED。
        • '\u000B' ,U + 000B垂直'\u000B'
        • '\f' ,U + 000C FORM FEED。
        • '\r' ,U + 000D运输返回。
        • '\u001C' ,U + 001C文件分离器。
        • '\u001D' ,U + 001D GROUP '\u001D'
        • '\u001E' ,U + 001E RECORD分隔器。
        • '\u001F' ,U + 001F UNIT SEPARATOR。
        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        true如果字符是Java空格字符; false否则。
        从以下版本开始:
        1.5
        另请参见:
        isSpaceChar(int)
      • isISOControl

        public static boolean isISOControl​(char ch)
        确定指定的字符是否是ISO控制字符。 一个字符被认为如果其代码是在范围为ISO控制字符'\u0000'通过'\u001F'或在范围'\u007F'通过'\u009F'

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符(包括补充字符),请使用isISOControl(int)方法。

        参数
        ch - 要测试的字符。
        结果
        true如果字符是ISO控制字符; 否则为false
        从以下版本开始:
        1.1
        另请参见:
        isSpaceChar(char)isWhitespace(char)
      • isISOControl

        public static boolean isISOControl​(int codePoint)
        确定引用的字符(Unicode代码点)是否是ISO控制字符。 一个字符被认为如果其代码是在范围为ISO控制字符'\u0000'通过'\u001F'或在范围'\u007F'通过'\u009F'
        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        true如果字符是ISO控制字符; 否则为false
        从以下版本开始:
        1.5
        另请参见:
        isSpaceChar(int)isWhitespace(int)
      • forDigit

        public static char forDigit​(int digit,
                                    int radix)
        确定指定基数中特定数字的字符表示。 如果radix的值不是有效的基数,或者digit的值不是指定基数中的有效数字,则返回空字符( '\u0000' )。

        radix参数是有效的,如果它是大于或等于MIN_RADIX且小于或等于MAX_RADIX digit参数是有效的,如果是0 <= digit < radix

        如果数字小于10,则返回'0' + digit 否则返回值'a' + digit - 10

        参数
        digit - 转换为字符的数字。
        radix - 基数。
        结果
        指定基数的指定数字的 char表示。
        另请参见:
        MIN_RADIXMAX_RADIXdigit(char, int)
      • isMirrored

        public static boolean isMirrored​(char ch)
        根据Unicode规范确定字符是否镜像。 当从右到左的文本中显示时,镜像字符应具有水平镜像的字形。 例如, '\u0028' LEFT PARENTHESIS在语义上被定义为一个开始的括号 在右到左的文本中,这将显示为“(”在文本中是从左到右,但作为“)”。

        注意:此方法无法处理supplementary characters 要支持所有Unicode字符,包括补充字符,请使用isMirrored(int)方法。

        参数
        ch - char ,请求镜像属性
        结果
        true如果char被镜像,则 false如果 char未镜像或未定义。
        从以下版本开始:
        1.4
      • isMirrored

        public static boolean isMirrored​(int codePoint)
        确定是否根据Unicode规范镜像指定的字符(Unicode代码点)。 当从右到左的文本中显示时,镜像字符应具有水平镜像的字形。 例如, '\u0028' LEFT PARENTHESIS在语义上被定义为开始的括号 在右到左的文本中,这将显示为“(”在文本中是从左到右,但作为“)”。
        参数
        codePoint - 要测试的字符(Unicode代码点)。
        结果
        true如果字符被镜像, false如果字符未镜像或未定义。
        从以下版本开始:
        1.5
      • compareTo

        public int compareTo​(Character anotherCharacter)
        数字比较两个 Character对象。
        Specified by:
        compareTo在接口 Comparable<Character>
        参数
        anotherCharacter - 要比较的 Character
        结果
        0如果参数Character等于这个Character ; 一个值小于0如果这个Character在数字上小于Character参数; 和大于一个值0 ,如果这Character在数值上比越大Character参数(无符号比较)。 请注意,这是严格的数值比较; 它不是区域设置相关的。
        从以下版本开始:
        1.2
      • compare

        public static int compare​(char x,
                                  char y)
        数值比较两个char 返回的值与以下内容相同:
          Character.valueOf(x).compareTo(Character.valueOf(y)) 
        参数
        x char
        y - 第二个 char进行比较
        结果
        价值0如果是x == y ; 一个值小于0如果是x < y ; 新新0 x > y
        从以下版本开始:
        1.7
      • reverseBytes

        public static char reverseBytes​(char ch)
        返回通过反转指定的 char值中的字节顺序获得的值。
        参数
        ch - 其中的 char反转字节顺序。
        结果
        通过在指定的 char值中反转(或等效地交换)字节获得的值。
        从以下版本开始:
        1.5
      • getName

        public static String getName​(int codePoint)
        返回指定字符的Unicode名称codePoint ,如果代码点为unassigned ,则返回null。

        注意:如果指定的字符未由UnicodeData文件(Unicode Consortium维护的Unicode字符数据库的一部分)分配名称,则返回的名称与表达式的结果相同。

        Character.UnicodeBlock.of(codePoint).toString().replace('_', ' ') + " " + Integer.toHexString(codePoint).toUpperCase(Locale.ROOT);
        参数
        codePoint - 字符(Unicode码点)
        结果
        指定字符的Unicode名称,如果代码点未分配,则为null。
        异常
        IllegalArgumentException - 如果指定的 codePoint不是有效的Unicode代码点。
        从以下版本开始:
        1.7
      • codePointOf

        public static int codePointOf​(String name)
        返回由给定的Unicode字符名称指定的Unicode字符的代码点值。

        注意:如果UnicodeData文件(由Unicode Consortium维护的Unicode字符数据库的一部分)未分配字符,则其名称将被定义为表达式的结果

        Character.UnicodeBlock.of(codePoint).toString().replace('_', ' ') + " " + Integer.toHexString(codePoint).toUpperCase(Locale.ROOT);

        name匹配不区分大小写,删除任何前导和尾随空格。

        参数
        name - Unicode字符名称
        结果
        由其名称指定的字符的代码点值。
        异常
        IllegalArgumentException - 如果指定的 name不是有效的Unicode字符名称。
        NullPointerException - 如果 namenull
        从以下版本开始:
        9