返回介绍
文江博客 开发文档 Java 中文参考手册 文章详情

java.lang 类 Character

发布于 2019-10-04 09:50:54 字数 130753 浏览 839 评论 0 收藏 0

java.lang.Object
  └java.lang.Character
所有已实现的接口：
Serializable, Comparable<Character>
public final class Character
extends Object
 
implements Serializable, Comparable<Character>
 

Character 类在对象中包装一个基本类型 char 的值。 Character 类型的对象包含类型为 char 的单个字段。

此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。

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

Character 类的方法和数据是通过 UnicodeData 文件中的信息定义的，该文件是 Unicode Consortium 维护的 Unicode Character Database 的一部分。此文件指定了各种属性，其中包括每个已定义 Unicode 代码点或字符范围的名称和常规类别。

此文件及其描述可从 Unicode Consortium 获得，网址如下：

  • http://www.unicode.org

Unicode Character Representations

char 数据类型（和 Character 对象封装的值）基于原始的 Unicode 规范，将字符定义为固定宽度的 16 位实体。Unicode 标准曾做过修改，以允许那些其表示形式需要超过 16 位的字符。合法代码点 的范围现在是从 U+0000 到 U+10FFFF，即通常所说的 Unicode 标量值。（请参阅 Unicode 标准中 U+n 表示法的定义。）

从 U+0000 到 U+FFFF 的字符集有时也称为 Basic Multilingual Plane (BMP)。代码点大于 U+FFFF 的字符称为增补字符。Java 2 平台在 char 数组以及 String 和 StringBuffer 类中使用 UTF-16 表示形式。在这种表现形式中，增补字符表示为一对 char 值，第一个值取自高代理项 范围，即 (\uD800-\uDBFF)，第二个值取自低代理项 范围，即 (\uDC00-\uDFFF)。

所以， char 值表示 Basic Multilingual Plane (BMP) 代码点，其中包括代理项代码点，或 UTF-16 编码的代码单元。 int 值表示所有 Unicode 代码点，包括增补代码点。 int 的 21 个低位（最低有效位）用于表示 Unicode 代码点，并且 11 个高位（最高有效位）必须为零。除非另有指定，否则与增补字符和代理项 char 值有关的行为如下：

  • 只接受一个 char 值的方法无法支持增补字符。它们将代理项字符范围内的 char 值视为未定义字符。例如， Character.isLetter('\uD840') 返回 false ，即使是特定值，如果在字符串的后面跟着任何低代理项值，那么它将表示一个字母。
  • 接受一个 int 值的方法支持所有 Unicode 字符，其中包括增补字符。例如， Character.isLetter(0x2F81A) 返回 true ，因为代码点值表示一个字母（一个 CJK 象形文字）。

在 J2SE API 文档中，Unicode 代码点 用于范围在 U+0000 与 U+10FFFF 之间的字符值，而 Unicode 代码点 用于作为 UTF-16 编码的代码单元的 16 位 char 值。有关 Unicode 技术的详细信息，请参阅 Unicode Glossary。

从以下版本开始：
1.0
另请参见：
序列化表格
嵌套类摘要
staticclassCharacter.Subset

此类的实例表示 Unicode 字符集的特定子集。

staticclassCharacter.UnicodeBlock

表示 Unicode 规范中字符块的一系列字符子集。

字段摘要
staticbyteCOMBINING_SPACING_MARK

Unicode 规范中的常规类别“Mc”。

staticbyteCONNECTOR_PUNCTUATION

Unicode 规范中的常规类别“Pc”。

staticbyteCONTROL

Unicode 规范中的常规类别“Cc”。

staticbyteCURRENCY_SYMBOL

Unicode 规范中的常规类别“Sc”。

staticbyteDASH_PUNCTUATION

Unicode 规范中的常规类别“Pd”。

staticbyteDECIMAL_DIGIT_NUMBER

Unicode 规范中的常规类别“Nd”。

staticbyteDIRECTIONALITY_ARABIC_NUMBER

Unicode 规范中的弱双向字符类型“AN”。

staticbyteDIRECTIONALITY_BOUNDARY_NEUTRAL

Unicode 规范中的弱双向字符类型“BN”。

staticbyteDIRECTIONALITY_COMMON_NUMBER_SEPARATOR

Unicode 规范中的弱双向字符类型“CS”。

staticbyteDIRECTIONALITY_EUROPEAN_NUMBER

Unicode 规范中的弱双向字符类型“EN”。

staticbyteDIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR

Unicode 规范中的弱双向字符类型“ES”。

staticbyteDIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR

Unicode 规范中的弱双向字符类型“ET”。

staticbyteDIRECTIONALITY_LEFT_TO_RIGHT

Unicode 规范中的强双向字符类型“L”。

staticbyteDIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING

Unicode 规范中的强双向字符类型“LRE”。

staticbyteDIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE

Unicode 规范中的强双向字符类型“LRO”。

staticbyteDIRECTIONALITY_NONSPACING_MARK

Unicode 规范中的弱双向字符类型“NSM”。

staticbyteDIRECTIONALITY_OTHER_NEUTRALS

Unicode 规范中的非特定双向字符类型“ON”。

staticbyteDIRECTIONALITY_PARAGRAPH_SEPARATOR

Unicode 规范中的非特定双向字符类型“B”。

staticbyteDIRECTIONALITY_POP_DIRECTIONAL_FORMAT

Unicode 规范中的弱双向字符类型“PDF”。

staticbyteDIRECTIONALITY_RIGHT_TO_LEFT

Unicode 规范中的强双向字符类型“R”。

staticbyteDIRECTIONALITY_RIGHT_TO_LEFT_ARABIC

Unicode 规范中的强双向字符类型“AL”。

staticbyteDIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING

Unicode 规范中的强双向字符类型“RLE”。

staticbyteDIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE

Unicode 规范中的强双向字符类型“RLO”。

staticbyteDIRECTIONALITY_SEGMENT_SEPARATOR

Unicode 规范中的非特定双向字符类型“S”。

staticbyteDIRECTIONALITY_UNDEFINED

未定义的双向字符类型。

staticbyteDIRECTIONALITY_WHITESPACE

Unicode 规范中的非特定双向字符类型“WS”。

staticbyteENCLOSING_MARK

Unicode 规范中的常规类别“Me”。

staticbyteEND_PUNCTUATION

Unicode 规范中的常规类别“Pe”。

staticbyteFINAL_QUOTE_PUNCTUATION

Unicode 规范中的常规类别“Pf”。

staticbyteFORMAT

Unicode 规范中的常规类别“Cf”。

staticbyteINITIAL_QUOTE_PUNCTUATION

Unicode 规范中的常规类别“Pi”。

staticbyteLETTER_NUMBER

Unicode 规范中的常规类别“Nl”。

staticbyteLINE_SEPARATOR

Unicode 规范中的常规类别“Zl”。

staticbyteLOWERCASE_LETTER

Unicode 规范中的常规类别“Ll”。

staticbyteMATH_SYMBOL

Unicode 规范中的常规类别“Sm”。

staticintMAX_CODE_POINT

Unicode 代码点的最大值。

staticcharMAX_HIGH_SURROGATE

UTF-16 编码中的 Unicode 高代理项代码单元的最大值。

staticcharMAX_LOW_SURROGATE

UTF-16 编码中的 Unicode 低代理项代码单元的最大值。

staticintMAX_RADIX

可用于与字符串相互转换的最大基数。

staticcharMAX_SURROGATE

UTF-16 编码中的 Unicode 代理项代码单元的最大值。

staticcharMAX_VALUE

此字段的常量值是 char 类型的最大值，即 '\uFFFF' 。

staticintMIN_CODE_POINT

Unicode 代码点的最小值。

staticcharMIN_HIGH_SURROGATE

UTF-16 编码中的 Unicode 高代理项代码单元的最小值。

staticcharMIN_LOW_SURROGATE

UTF-16 编码中的 Unicode 低代理项代码单元的最小值。

staticintMIN_RADIX

可用于与字符串相互转换的最小基数。

staticintMIN_SUPPLEMENTARY_CODE_POINT

增补代码点的最小值。

staticcharMIN_SURROGATE

UTF-16 编码中的 Unicode 代理项代码单元的最小值。

staticcharMIN_VALUE

此字段的常量值是 char 类型的最小值，即 '\u0000' 。

staticbyteMODIFIER_LETTER

Unicode 规范中的常规类别“Lm”。

staticbyteMODIFIER_SYMBOL

Unicode 规范中的常规类别“Sk”。

staticbyteNON_SPACING_MARK

Unicode 规范中的常规类别“Mn”。

staticbyteOTHER_LETTER

Unicode 规范中的常规类别“Lo”。

staticbyteOTHER_NUMBER

Unicode 规范中的常规类别“No”。

staticbyteOTHER_PUNCTUATION

Unicode 规范中的常规类别“Po”。

staticbyteOTHER_SYMBOL

Unicode 规范中的常规类别“So”。

staticbytePARAGRAPH_SEPARATOR

Unicode 规范中的常规类别“Zp”。

staticbytePRIVATE_USE

Unicode 规范中的常规类别“Co”。

staticintSIZE

用来以无符号二进制形式表示 char 值的位数。

staticbyteSPACE_SEPARATOR

Unicode 规范中的常规类别“Zs”。

staticbyteSTART_PUNCTUATION

Unicode 规范中的常规类别“Ps”。

staticbyteSURROGATE

Unicode 规范中的常规类别“Cs”。

staticbyteTITLECASE_LETTER

Unicode 规范中的常规类别“Lt”。

staticClass<Character>TYPE

表示基本类型 char 的 Class 实例。

staticbyteUNASSIGNED

Unicode 规范中的常规类别“Cn”。

staticbyteUPPERCASE_LETTER

Unicode 规范中的常规类别“Lu”。

构造方法摘要
Character(charvalue)

构造一个新分配的 Character 对象，用以表示指定的 char 值。

方法摘要
staticintcharCount(intcodePoint)

确定表示指定字符（Unicode 代码点）所需的 char 值的数量。

charcharValue()

返回此 Character 对象的值。

staticintcodePointAt(char[]a, intindex)

返回 char 数组的给定索引上的代码点。

staticintcodePointAt(char[]a, intindex, intlimit)

返回 char 数组的给定索引上的代码点，该数组中只有那些具有小于 limit 的 index 值的数组元素可以使用。

staticintcodePointAt(CharSequenceseq, intindex)

返回 CharSequence 的给定索引上的代码点。

staticintcodePointBefore(char[]a, intindex)

返回 char 数组的给定索引前面的代码点。

staticintcodePointBefore(char[]a, intindex, intstart)

返回 char 数组的给定索引前面的代码点，该数组中只有那些具有大于或等于 start 的 index 值的数组元素可以使用。

staticintcodePointBefore(CharSequenceseq, intindex)

返回 CharSequence 的给定索引前面的代码点。

staticintcodePointCount(char[]a, intoffset, intcount)

返回 char 数组参数的子数组中的 Unicode 代码点的数量。

staticintcodePointCount(CharSequenceseq, intbeginIndex, intendIndex)

返回指定字符序列的文本范围内的 Unicode 代码点数量。

intcompareTo(CharacteranotherCharacter)

根据数字比较两个 Character 对象。

staticintdigit(charch, intradix)

返回使用指定基数的字符 ch 的值。

staticintdigit(intcodePoint, intradix)

返回使用指定基数的指定字符（Unicode 代码点）的数值。

booleanequals(Objectobj)

将此对象与指定对象比较。

staticcharforDigit(intdigit, intradix)

确定使用指定基数的特定数字的字符表示形式。

staticbytegetDirectionality(charch)

返回给定字符的 Unicode 方向属性。

staticbytegetDirectionality(intcodePoint)

返回给定字符（Unicode 代码点）的 Unicode 方向属性。

staticintgetNumericValue(charch)

返回指定的 Unicode 字符表示的 int 值。

staticintgetNumericValue(intcodePoint)

返回指定字符（Unicode 代码点）表示的 int 值。

staticintgetType(charch)

返回一个指示字符的常规类别的值。

staticintgetType(intcodePoint)

返回一个指示字符的常规类别的值。

inthashCode()

返回此 Character 的哈希码。

staticbooleanisDefined(charch)

确定指定字符是否被定义为 Unicode 中的字符。

staticbooleanisDefined(intcodePoint)

确定指定字符（Unicode 代码点）是否为字符。

staticbooleanisDigit(charch)

确定指定字符是否为数字。

staticbooleanisDigit(intcodePoint)

确定指定字符（Unicode 代码点）是否为数字。

staticbooleanisHighSurrogate(charch)

确定给出的 char 值是否为一个高代理项代码单元（也称为前导代理项代码单元）。

staticbooleanisIdentifierIgnorable(charch)

确定是否应该认为指定字符是 Java 标识符或 Unicode 标识符中可忽略的一个字符。

staticbooleanisIdentifierIgnorable(intcodePoint)

确定是否应该认为指定字符（Unicode 代码点）是 Java 标识符或 Unicode 标识符中可忽略的一个字符。

staticbooleanisISOControl(charch)

确定指定字符是否为 ISO 控制字符。

staticbooleanisISOControl(intcodePoint)

确定引用的字符（Unicode 代码点）是否 ISO 控制字符。

staticbooleanisJavaIdentifierPart(charch)

确定指定字符是否可以是 Java 标识符中首字符以外的部分。

staticbooleanisJavaIdentifierPart(intcodePoint)

确定字符（Unicode 代码点）是否可以是 Java 标识符中首字符以外的部分。

staticbooleanisJavaIdentifierStart(charch)

确定是否允许将指定字符作为 Java 标识符中的首字符。

staticbooleanisJavaIdentifierStart(intcodePoint)

确定是否允许将字符（Unicode 代码点）作为 Java 标识符中的首字符。

staticbooleanisJavaLetter(charch)

已过时。用 isJavaIdentifierStart(char) 取代。

staticbooleanisJavaLetterOrDigit(charch)

已过时。用 isJavaIdentifierPart(char) 取代。

staticbooleanisLetter(charch)

确定指定字符是否为字母。

staticbooleanisLetter(intcodePoint)

确定指定字符（Unicode 代码点）是否为字母。

staticbooleanisLetterOrDigit(charch)

确定指定字符是否为字母或数字。

staticbooleanisLetterOrDigit(intcodePoint)

确定指定字符（Unicode 代码点）是否字母或数字。

staticbooleanisLowerCase(charch)

确定指定字符是否为小写字母。

staticbooleanisLowerCase(intcodePoint)

确定指定字符（Unicode 代码点）是否为小写字母。

staticbooleanisLowSurrogate(charch)

确定给定 char 值是否一个低代理项代码单元（也称为尾部代理项代码单元）。

staticbooleanisMirrored(charch)

确定指定字符依据 Unicode 规范是否对称。

staticbooleanisMirrored(intcodePoint)

确定指定字符（Unicode 代码点）依据 Unicode 规范是否对称。

staticbooleanisSpace(charch)

已过时。用 isWhitespace(char) 取代。

staticbooleanisSpaceChar(charch)

确定指定字符是否为 Unicode 空白字符。

staticbooleanisSpaceChar(intcodePoint)

确定指定字符（Unicode 代码点）是否为 Unicode 空白字符。

staticbooleanisSupplementaryCodePoint(intcodePoint)

确定指定字符（Unicode 代码点）是否在增补字符范围内。

staticbooleanisSurrogatePair(charhigh, charlow)

确定指定的 char 值对是否为有效的代理项对。

staticbooleanisTitleCase(charch)

确定指定字符是否为首字母大写字符。

staticbooleanisTitleCase(intcodePoint)

确定指定字符（Unicode 代码点）是否为首字母大写字符。

staticbooleanisUnicodeIdentifierPart(charch)

确定指定字符是否可以是 Unicode 标识符中首字符以外的部分。

staticbooleanisUnicodeIdentifierPart(intcodePoint)

确定指定字符（Unicode 代码点）是否可以是 Unicode 标识符中首字符以外的部分。

staticbooleanisUnicodeIdentifierStart(charch)

确定是否允许将指定字符作为 Unicode 标识符中的首字符。

staticbooleanisUnicodeIdentifierStart(intcodePoint)

确定是否允许将指定字符（Unicode 代码点）作为 Unicode 标识符中的首字符。

staticbooleanisUpperCase(charch)

确定指定字符是否为大写字母。

staticbooleanisUpperCase(intcodePoint)

确定指定字符（Unicode 代码点）是否为大写字母。

staticbooleanisValidCodePoint(intcodePoint)

确定指定的代码点是否为从 0x0000 到 0x10FFFF 范围之内的有效 Unicode 代码点值。

staticbooleanisWhitespace(charch)

确定指定字符依据 Java 标准是否为空白字符。

staticbooleanisWhitespace(intcodePoint)

确定指定字符（Unicode 代码点）依据 Java 标准是否为空白字符。

staticintoffsetByCodePoints(char[]a, intstart, intcount, intindex, intcodePointOffset)

返回给定 char 子数组中的索引，它是从给定 index 到 codePointOffset 代码点的偏移量。

staticintoffsetByCodePoints(CharSequenceseq, intindex, intcodePointOffset)

返回给定字符序列中的索引，它是从给定 index 到 codePointOffset 代码点的偏移量。

staticcharreverseBytes(charch)

返回通过反转指定 char 值中的字节顺序而获得的值。

staticchar[]toChars(intcodePoint)

将指定的字符（Unicode 代码点）转换成其存储在 char 数组中的 UTF-16 表示形式。

staticinttoChars(intcodePoint, char[]dst, intdstIndex)

将指定字符（Unicode 代码点）转换为其 UTF-16 表示形式。

staticinttoCodePoint(charhigh, charlow)

将指定的代理项对转换为其增补代码点值。

staticchartoLowerCase(charch)

使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为小写。

staticinttoLowerCase(intcodePoint)

使用来自 UnicodeData 文件的大小写映射信息将字符（Unicode 代码点）参数转换为小写。

StringtoString()

返回表示此 Character 值的 String 对象。

staticStringtoString(charc)

返回一个表示指定 char 值的 String 对象。

staticchartoTitleCase(charch)

使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为首字母大写。

staticinttoTitleCase(intcodePoint)

使用来自 UnicodeData 文件的大小写映射信息将字符（Unicode 代码点）参数转换为首字母大写。

staticchartoUpperCase(charch)

使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为大写。

staticinttoUpperCase(intcodePoint)

使用来自 UnicodeData 文件的大小写映射信息将字符（Unicode 代码点）参数转换为大写。

staticCharactervalueOf(charc)

返回一个表示指定 char 值的 Character 实例。

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

字段详细信息

MIN_RADIX

public static final int MIN_RADIX
可用于与字符串相互转换的最小基数。此字段的常量值是基数转换方法（比如 Integer 类的 digit 、 forDigit 和 toString 方法）中所允许的基数参数的最小值。
另请参见：
digit(char, int) , forDigit(int, int) , Integer.toString(int, int) , Integer.valueOf(java.lang.String) , 常量字段值

MAX_RADIX

public static final int MAX_RADIX
可用于与字符串相互转换的最大基数。此字段的常量值是基数转换方法（比如 Integer 类的 digit 、 forDigit 和 toString 方法）中所允许的基数参数的最大值。
另请参见：
digit(char, int) , forDigit(int, int) , Integer.toString(int, int) , Integer.valueOf(java.lang.String) , 常量字段值

MIN_VALUE

public static final char MIN_VALUE
此字段的常量值是 char 类型的最小值，即 '\u0000' 。
从以下版本开始：
1.0.2
另请参见：
常量字段值

MAX_VALUE

public static final char MAX_VALUE
此字段的常量值是 char 类型的最大值，即 '\uFFFF' 。
从以下版本开始：
1.0.2
另请参见：
常量字段值

TYPE

public static final Class<Character> TYPE
表示基本类型 char 的 Class 实例。
从以下版本开始：
1.1

UNASSIGNED

public static final byte UNASSIGNED
Unicode 规范中的常规类别“Cn”。
从以下版本开始：
1.1
另请参见：
常量字段值

UPPERCASE_LETTER

public static final byte UPPERCASE_LETTER
Unicode 规范中的常规类别“Lu”。
从以下版本开始：
1.1
另请参见：
常量字段值

LOWERCASE_LETTER

public static final byte LOWERCASE_LETTER
Unicode 规范中的常规类别“Ll”。
从以下版本开始：
1.1
另请参见：
常量字段值

TITLECASE_LETTER

public static final byte TITLECASE_LETTER
Unicode 规范中的常规类别“Lt”。
从以下版本开始：
1.1
另请参见：
常量字段值

MODIFIER_LETTER

public static final byte MODIFIER_LETTER
Unicode 规范中的常规类别“Lm”。
从以下版本开始：
1.1
另请参见：
常量字段值

OTHER_LETTER

public static final byte OTHER_LETTER
Unicode 规范中的常规类别“Lo”。
从以下版本开始：
1.1
另请参见：
常量字段值

NON_SPACING_MARK

public static final byte NON_SPACING_MARK
Unicode 规范中的常规类别“Mn”。
从以下版本开始：
1.1
另请参见：
常量字段值

ENCLOSING_MARK

public static final byte ENCLOSING_MARK
Unicode 规范中的常规类别“Me”。
从以下版本开始：
1.1
另请参见：
常量字段值

COMBINING_SPACING_MARK

public static final byte COMBINING_SPACING_MARK
Unicode 规范中的常规类别“Mc”。
从以下版本开始：
1.1
另请参见：
常量字段值

DECIMAL_DIGIT_NUMBER

public static final byte DECIMAL_DIGIT_NUMBER
Unicode 规范中的常规类别“Nd”。
从以下版本开始：
1.1
另请参见：
常量字段值

LETTER_NUMBER

public static final byte LETTER_NUMBER
Unicode 规范中的常规类别“Nl”。
从以下版本开始：
1.1
另请参见：
常量字段值

OTHER_NUMBER

public static final byte OTHER_NUMBER
Unicode 规范中的常规类别“No”。
从以下版本开始：
1.1
另请参见：
常量字段值

SPACE_SEPARATOR

public static final byte SPACE_SEPARATOR
Unicode 规范中的常规类别“Zs”。
从以下版本开始：
1.1
另请参见：
常量字段值

LINE_SEPARATOR

public static final byte LINE_SEPARATOR
Unicode 规范中的常规类别“Zl”。
从以下版本开始：
1.1
另请参见：
常量字段值

PARAGRAPH_SEPARATOR

public static final byte PARAGRAPH_SEPARATOR
Unicode 规范中的常规类别“Zp”。
从以下版本开始：
1.1
另请参见：
常量字段值

CONTROL

public static final byte CONTROL
Unicode 规范中的常规类别“Cc”。
从以下版本开始：
1.1
另请参见：
常量字段值

FORMAT

public static final byte FORMAT
Unicode 规范中的常规类别“Cf”。
从以下版本开始：
1.1
另请参见：
常量字段值

PRIVATE_USE

public static final byte PRIVATE_USE
Unicode 规范中的常规类别“Co”。
从以下版本开始：
1.1
另请参见：
常量字段值

SURROGATE

public static final byte SURROGATE
Unicode 规范中的常规类别“Cs”。
从以下版本开始：
1.1
另请参见：
常量字段值

DASH_PUNCTUATION

public static final byte DASH_PUNCTUATION
Unicode 规范中的常规类别“Pd”。
从以下版本开始：
1.1
另请参见：
常量字段值

START_PUNCTUATION

public static final byte START_PUNCTUATION
Unicode 规范中的常规类别“Ps”。
从以下版本开始：
1.1
另请参见：
常量字段值

END_PUNCTUATION

public static final byte END_PUNCTUATION
Unicode 规范中的常规类别“Pe”。
从以下版本开始：
1.1
另请参见：
常量字段值

CONNECTOR_PUNCTUATION

public static final byte CONNECTOR_PUNCTUATION
Unicode 规范中的常规类别“Pc”。
从以下版本开始：
1.1
另请参见：
常量字段值

OTHER_PUNCTUATION

public static final byte OTHER_PUNCTUATION
Unicode 规范中的常规类别“Po”。
从以下版本开始：
1.1
另请参见：
常量字段值

MATH_SYMBOL

public static final byte MATH_SYMBOL
Unicode 规范中的常规类别“Sm”。
从以下版本开始：
1.1
另请参见：
常量字段值

CURRENCY_SYMBOL

public static final byte CURRENCY_SYMBOL
Unicode 规范中的常规类别“Sc”。
从以下版本开始：
1.1
另请参见：
常量字段值

MODIFIER_SYMBOL

public static final byte MODIFIER_SYMBOL
Unicode 规范中的常规类别“Sk”。
从以下版本开始：
1.1
另请参见：
常量字段值

OTHER_SYMBOL

public static final byte OTHER_SYMBOL
Unicode 规范中的常规类别“So”。
从以下版本开始：
1.1
另请参见：
常量字段值

INITIAL_QUOTE_PUNCTUATION

public static final byte INITIAL_QUOTE_PUNCTUATION
Unicode 规范中的常规类别“Pi”。
从以下版本开始：
1.4
另请参见：
常量字段值

FINAL_QUOTE_PUNCTUATION

public static final byte FINAL_QUOTE_PUNCTUATION
Unicode 规范中的常规类别“Pf”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_UNDEFINED

public static final byte DIRECTIONALITY_UNDEFINED
未定义的双向字符类型。未定义的 char 值在 Unicode 规范中具有未定义的方向性。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_LEFT_TO_RIGHT

public static final byte DIRECTIONALITY_LEFT_TO_RIGHT
Unicode 规范中的强双向字符类型“L”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_RIGHT_TO_LEFT

public static final byte DIRECTIONALITY_RIGHT_TO_LEFT
Unicode 规范中的强双向字符类型“R”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC

public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
Unicode 规范中的强双向字符类型“AL”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_EUROPEAN_NUMBER

public static final byte DIRECTIONALITY_EUROPEAN_NUMBER
Unicode 规范中的弱双向字符类型“EN”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR

public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
Unicode 规范中的弱双向字符类型“ES”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR

public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
Unicode 规范中的弱双向字符类型“ET”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_ARABIC_NUMBER

public static final byte DIRECTIONALITY_ARABIC_NUMBER
Unicode 规范中的弱双向字符类型“AN”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_COMMON_NUMBER_SEPARATOR

public static final byte DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
Unicode 规范中的弱双向字符类型“CS”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_NONSPACING_MARK

public static final byte DIRECTIONALITY_NONSPACING_MARK
Unicode 规范中的弱双向字符类型“NSM”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_BOUNDARY_NEUTRAL

public static final byte DIRECTIONALITY_BOUNDARY_NEUTRAL
Unicode 规范中的弱双向字符类型“BN”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_PARAGRAPH_SEPARATOR

public static final byte DIRECTIONALITY_PARAGRAPH_SEPARATOR
Unicode 规范中的非特定双向字符类型“B”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_SEGMENT_SEPARATOR

public static final byte DIRECTIONALITY_SEGMENT_SEPARATOR
Unicode 规范中的非特定双向字符类型“S”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_WHITESPACE

public static final byte DIRECTIONALITY_WHITESPACE
Unicode 规范中的非特定双向字符类型“WS”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_OTHER_NEUTRALS

public static final byte DIRECTIONALITY_OTHER_NEUTRALS
Unicode 规范中的非特定双向字符类型“ON”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING

public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
Unicode 规范中的强双向字符类型“LRE”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE

public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
Unicode 规范中的强双向字符类型“LRO”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING

public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
Unicode 规范中的强双向字符类型“RLE”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE

public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
Unicode 规范中的强双向字符类型“RLO”。
从以下版本开始：
1.4
另请参见：
常量字段值

DIRECTIONALITY_POP_DIRECTIONAL_FORMAT

public static final byte DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
Unicode 规范中的弱双向字符类型“PDF”。
从以下版本开始：
1.4
另请参见：
常量字段值

MIN_HIGH_SURROGATE

public static final char MIN_HIGH_SURROGATE
UTF-16 编码中的 Unicode 高代理项代码单元的最小值。高代理项也称为前导代理项。
从以下版本开始：
1.5
另请参见：
常量字段值

MAX_HIGH_SURROGATE

public static final char MAX_HIGH_SURROGATE
UTF-16 编码中的 Unicode 高代理项代码单元的最大值。高代理项也称为前导代理项。
从以下版本开始：
1.5
另请参见：
常量字段值

MIN_LOW_SURROGATE

public static final char MIN_LOW_SURROGATE
UTF-16 编码中的 Unicode 低代理项代码单元的最小值。低代理项也称为尾部代理项。
从以下版本开始：
1.5
另请参见：
常量字段值

MAX_LOW_SURROGATE

public static final char MAX_LOW_SURROGATE
UTF-16 编码中的 Unicode 低代理项代码单元的最大值。低代理项也称为尾部代理项。
从以下版本开始：
1.5
另请参见：
常量字段值

MIN_SURROGATE

public static final char MIN_SURROGATE
UTF-16 编码中的 Unicode 代理项代码单元的最小值。
从以下版本开始：
1.5
另请参见：
常量字段值

MAX_SURROGATE

public static final char MAX_SURROGATE
UTF-16 编码中的 Unicode 代理项代码单元的最大值。
从以下版本开始：
1.5
另请参见：
常量字段值

MIN_SUPPLEMENTARY_CODE_POINT

public static final int MIN_SUPPLEMENTARY_CODE_POINT
增补代码点的最小值。
从以下版本开始：
1.5
另请参见：
常量字段值

MIN_CODE_POINT

public static final int MIN_CODE_POINT
Unicode 代码点的最小值。
从以下版本开始：
1.5
另请参见：
常量字段值

MAX_CODE_POINT

public static final int MAX_CODE_POINT
Unicode 代码点的最大值。
从以下版本开始：
1.5
另请参见：
常量字段值

SIZE

public static final int SIZE
用来以无符号二进制形式表示 char 值的位数。
从以下版本开始：
1.5
另请参见：
常量字段值

构造方法详细信息

Character

public Character(charvalue)
构造一个新分配的 Character 对象，用以表示指定的 char 值。
参数：
value - Character 对象表示的值。

方法详细信息

valueOf

public static Character valueOf(charc)
返回一个表示指定 char 值的 Character 实例。如果不需要新的 Character 实例，则通常应该优先采用此方法，而不是构造方法 Character(char) ，因为该方法很可能通过缓存经常请求的值来显著提高空间和时间性能。
参数：
c - 一个 char 值。
返回：
表示 c 的 Character 实例。
从以下版本开始：
1.5

charValue

public char charValue()
返回此 Character 对象的值。
返回：
此对象表示的基本 char 值。

hashCode

public int hashCode()
返回此 Character 的哈希码。
覆盖：
类 Object 中的 hashCode
返回：
此对象的哈希码值。
另请参见：
Object.equals(java.lang.Object) , Hashtable

equals

public boolean equals(Objectobj)
将此对象与指定对象比较。当且仅当参数不是 null ，而是一个与此对象包含相同 char 值的 Character 对象时，结果才是 true 。
覆盖：
类 Object 中的 equals
参数：
obj - 比较的对象。
返回：
如果对象相同，则返回 true ；否则返回 false 。
另请参见：
Object.hashCode() , Hashtable

toString

public String toString()
返回表示此 Character 值的 String 对象。结果是一个长度为 1 的字符串，其惟一组件是此 Character 对象表示的基本 char 值。
覆盖：
类 Object 中的 toString
返回：
此对象的字符串表示形式。

toString

public static String toString(charc)
返回一个表示指定 char 值的 String 对象。结果是长度为 1 的字符串，仅由指定的 char 组成。
参数：
c - 要转换的 char 值
返回：
指定 char 值的字符串表示形式
从以下版本开始：
1.4

isValidCodePoint

public static boolean isValidCodePoint(intcodePoint)
确定指定的代码点是否为从 0x0000 到 0x10FFFF 范围之内的有效 Unicode 代码点值。该方法等效于以下表达式：
 codePoint >= 0x0000 && codePoint <= 0x10FFFF
参数：
codePoint - 要测试的 Unicode 代码点
返回：
如果指定的代码点值是一个有效的代码点值，则返回 true ；否则返回 false 。
从以下版本开始：
1.5

isSupplementaryCodePoint

public static boolean isSupplementaryCodePoint(intcodePoint)
确定指定字符（Unicode 代码点）是否在增补字符范围内。该方法调用以下表达式：
 codePoint >= 0x10000 && codePoint <= 0x10ffff
参数：
codePoint - 要测试的字符（Unicode 代码点）
返回：
如果指定字符在 Unicode 增补字符范围内，则返回 true ；否则返回 false 。
从以下版本开始：
1.5

isHighSurrogate

public static boolean isHighSurrogate(charch)
确定给出的 char 值是否为一个高代理项代码单元（也称为前导代理项代码单元）。这类值并不表示它们本身的字符，而被用来表示 UTF-16 编码中的增补字符。

该方法返回 true 的条件是当且仅当

ch >= '\uD800' && ch <= '\uDBFF'

为 true 。

参数：
ch - 要测试的 char 值。
返回：
如果 char 值在 '\uD800' 与 '\uDBFF' 所包含的范围之间，则返回 true ；否则返回 false 。
从以下版本开始：
1.5
另请参见：
isLowSurrogate(char) , Character.UnicodeBlock.of(int)

 

isLowSurrogate

public static boolean isLowSurrogate(charch)

确定给定 char 值是否一个低代理项代码单元（也称为尾部代理项代码单元）。这类值并不表示它们本身的字符，而被用来表示 UTF-16 编码中的增补字符。

该方法返回 true 的条件是当且仅当

ch >= '\uDC00' && ch <= '\uDFFF'

为 true 。

参数：
ch - 要测试的 char 值。
返回：
如果 char 值在 '\uDC00' 与 '\uDFFF' 所包含的范围之间，则返回 true ；否则返回 false 。
从以下版本开始：
1.5
另请参见：
isHighSurrogate(char)

isSurrogatePair

public static boolean isSurrogatePair(charhigh,
                                      charlow)

确定指定的 char 值对是否为有效的代理项对。该方法等效于以下表达式：
 isHighSurrogate(high) && isLowSurrogate(low)
参数：
high - 要测试的高代理项代码值
low - 要测试的低代理项代码值
返回：
如果指定的高代理项和低代理项代码值表示的是一个有效的代理项对，则返回 true ；否则返回 false 。
从以下版本开始：
1.5

charCount

public static int charCount(intcodePoint)

确定表示指定字符（Unicode 代码点）所需的 char 值的数量。如果指定字符等于或大于 0x10000，则该方法返回的值为 2。否则，该方法返回的值为 1。

该方法没有验证指定的字符是否为一个有效的 Unicode 代码点。如有必要，调用方必须使用 isValidCodePoint 验证字符值。

参数：
codePoint - 要测试的字符（Unicode 代码点）。
返回：
如果字符是一个有效的增补字符，则返回 2；否则返回 1。
从以下版本开始：
1.5
另请参见：
isSupplementaryCodePoint(int)

toCodePoint

public static int toCodePoint(charhigh,
                              charlow)

将指定的代理项对转换为其增补代码点值。该方法没有验证指定的代理项对。如有必要，调用方必须使用 isSurrogatePair 验证它。
参数：
high - 高代理项代码单元
low - 低代理项代码单元
返回：
用指定代理项对组成的增补代码点
从以下版本开始：
1.5

codePointAt

public static int codePointAt(CharSequenceseq,
                              intindex)

返回 CharSequence 的给定索引上的代码点。如果 CharSequence 中的给定索引上的 char 值在高代理项范围内，则下列索引的长度小于 CharSequence 的长度，如果下列索引上的 char 值在低代理项范围内，则返回对应于此代理项对的增补代码点。否则，返回给定索引上的 char 值。
参数：
seq - char 值（Unicode 代码单元）的序列
index - 要转换的 seq 中的 char 值（Unicode 代码单元）的索引
返回：
给定索引上的 Unicode 代码点
抛出：
NullPointerException - 如果 seq 为 null。
IndexOutOfBoundsException - 如果 index 值为负或不小于 seq.length() 。
从以下版本开始：
1.5

codePointAt

public static int codePointAt(char[]a,
                              intindex)

返回 char 数组的给定索引上的代码点。如果 char 数组中的给定索引上的 char 值在高代理项范围内，则下一个索引的长度小于 char 数组的长度，如果下一个索引上的 char 值在低代理项范围内，则返回对应于此代理项对的增补代码点。否则，返回给定索引上的 char 值。
参数：
a - char 数组
index - 要转换的 char 数组中的 char 值（Unicode 代码单元）的索引
返回：
给定索引上的 Unicode 代码点
抛出：
NullPointerException - 如果 a 为 null。
IndexOutOfBoundsException - 如果 index 值为负或不小于 char 数组的长度。
从以下版本开始：
1.5

codePointAt

public static int codePointAt(char[]a,
                              intindex,
                              intlimit)

返回 char 数组的给定索引上的代码点，该数组中只有那些具有小于 limit 的 index 值的数组元素可以使用。如果 char 数组中的给定索引上的 char 值在高代理项范围内，则下一个索引小于 limit ，如果下一个索引上的 char 值在低代理项范围内，则返回对应于此代理项对的增补代码点。否则，返回给定索引上的 char 值。
参数：
a - char 数组
index - 要转换的 char 数组中的 char 值（Unicode 代码点）的索引
limit - 可以在 char 数组中使用的最后一个数组元素后面的索引
返回：
给定索引上的 Unicode 代码点
抛出：
NullPointerException - 如果 a 为 null。
IndexOutOfBoundsException - 如果 index 参数为负或不小于 limit 参数，或者如果 limit 参数为负或大于 char 数组的长度。
从以下版本开始：
1.5

codePointBefore

public static int codePointBefore(CharSequenceseq,
                                  intindex)

返回 CharSequence 的给定索引前面的代码点。如果 CharSequence 中的 (index - 1) 上的 char 值在低代理项范围内，则 (index - 2) 为非负，如果 CharSequence 中的 (index - 2) 上的 char 值在高代理项范围内，则返回对应于此代理项对的增补代码点。否则，返回 (index - 1) 上的 char 值。
参数：
seq - CharSequence 实例
index - 应该返回的代码点后面的索引
返回：
给定索引前面的 Unicode 代码点值。
抛出：
NullPointerException - 如果 seq 为 null。
IndexOutOfBoundsException - 如果 index 参数小于 1 或者大于 seq.length() 。
从以下版本开始：
1.5

codePointBefore

public static int codePointBefore(char[]a,
                                  intindex)

返回 char 数组的给定索引前面的代码点。如果 char 数组中的 (index - 1) 上的 char 值在低代理项范围内，则 (index - 2) 为非负，如果 char 数组中的 (index - 2) 上的 char 值在高代理项范围内，则返回对应于此代理项对的增补代码点。否则，返回 (index - 1) 上的 char 值。
参数：
a - char 数组
index - 应该返回的代码点后面的索引
返回：
给定索引前面的 Unicode 代码点值。
抛出：
NullPointerException - 如果 a 为 null。
IndexOutOfBoundsException - 如果 index 参数小于 1 或大于 char 数组的长度
从以下版本开始：
1.5

codePointBefore

public static int codePointBefore(char[]a,
                                  intindex,
                                  intstart)

返回 char 数组的给定索引前面的代码点，该数组中只有那些具有大于或等于 start 的 index 值的数组元素可以使用。如果 char 数组中的 (index - 1) 上的 char 值在低代理项范围内，则 (index - 2) 不小于 start ，如果 char 数组中的 (index - 2) 上的 char 值在高代理项范围内，则返回对应于此代理项对的增补代码点。否则，返回 (index - 1) 上的 char 值。
参数：
a - char 数组
index - 应该返回的代码点后面的索引
start - char 数组中第一个数组元素的索引
返回：
给定索引前面的 Unicode 代码点。
抛出：
NullPointerException - 如果 a 为 null。
IndexOutOfBoundsException - 如果 index 参数不大于 start 参数或大于 char 数组的长度，或者如果 start 参数为负或小于 char 数组的长度。
从以下版本开始：
1.5

toChars

public static int toChars(intcodePoint,
                          char[]dst,
                          intdstIndex)

将指定字符（Unicode 代码点）转换为其 UTF-16 表示形式。如果指定代码点是一个 BMP（Basic Multilingual Plane 或 Plane 0）值，则在 dst[dstIndex] 中存储相同的值，并返回 1。如果指定代码点是一个增补字符，则将其代理项值存储在 dst[dstIndex] （高代理项）和 dst[dstIndex+1] （低代理项）中，并返回 2。
参数：
codePoint - 要转换的字符（Unicode 代码点）。
dst - char 的一个数组， codePoint 的 UTF-16 值存储在其中。
dstIndex - 进入存储已转换值的 dst 数组中的起始索引。
返回：
如果代码点是一个 BMP 代码点，则返回 1，如果代码点是一个增补代码点，则返回 2。
抛出：
IllegalArgumentException - 如果指定的 codePoint 不是一个有效的 Unicode 代码点。
NullPointerException - 如果指定的 dst 为 null。
IndexOutOfBoundsException - 如果 dstIndex 为负或不小于 dst.length ，或者如果 dstIndex 上的 dst 没有足够多的数组元素来存储得到的 char 值。（如果 dstIndex 等于 dst.length-1 并且指定的 codePoint 是一个增补字符，则不在 dst[dstIndex] 中存储高代理项值。）
从以下版本开始：
1.5

toChars

public static char[] toChars(intcodePoint)

将指定的字符（Unicode 代码点）转换成其存储在 char 数组中的 UTF-16 表示形式。如果指定的代码点是一个 BMP（Basic Multilingual Plane 或 Plane 0）值，则得到的 char 数组具有与 codePoint 相同的值。如果指定的代码点是一个增补代码点，则得到的 char 数组具有相应的代理项对。
参数：
codePoint - 一个 Unicode 代码点
返回：
一个具有 codePoint 的 UTF-16 表示形式的 char 数组。
抛出：
IllegalArgumentException - 如果指定的 codePoint 不是一个有效的 Unicode 代码点。
从以下版本开始：
1.5

codePointCount

public static int codePointCount(CharSequenceseq,
                                 intbeginIndex,
                                 intendIndex)

返回指定字符序列的文本范围内的 Unicode 代码点数量。文本范围始于指定的 beginIndex ，并扩展到索引 endIndex - 1 上的 char 。因此文本范围的长度（ char 形式）为 endIndex-beginIndex 。文本范围内的不成对代理项是按一个代码点算作一个项进行计数的。
参数：
seq - 字符序列
beginIndex - 文本范围的第一个 char 的索引。
endIndex - 文本范围的最后一个 char 后面的索引。
返回：
指定文本范围内的 Unicode 代码点的数量
抛出：
NullPointerException - 如果 seq 为 null。
IndexOutOfBoundsException - 如果 beginIndex 为负，或者 endIndex 大于给定序列的长度，或者 beginIndex 大于 endIndex 。
从以下版本开始：
1.5

codePointCount

public static int codePointCount(char[]a,
                                 intoffset,
                                 intcount)

返回 char 数组参数的子数组中的 Unicode 代码点的数量。 offset 参数是子数组的第一个 char 的索引， count 参数指定了 char 中的子数组的长度。子数组中不成对的代理项是按一个代码点算作一个项进行计数的。
参数：
a - char 数组
offset - 给定 char 数组中第一个 char 的索引
count - char 中的子数组的长度
返回：
指定子数组中 Unicode 代码点的数量
抛出：
NullPointerException - 如果 a 为 null。
IndexOutOfBoundsException - 如果 offset 或 count 为负，或者如果 offset + count 大于给定数组的长度。
从以下版本开始：
1.5

offsetByCodePoints

public static int offsetByCodePoints(CharSequenceseq,
                                     intindex,
                                     intcodePointOffset)

返回给定字符序列中的索引，它是从给定 index 到 codePointOffset 代码点的偏移量。 index 和 codePointOffset 给出的文本范围内的不成对代理项是按一个代码点算作一个项进行计数的。
参数：
seq - 字符序列
index - 要偏移的索引
codePointOffset - 代码点中的偏移量
返回：
字符序列内的索引
抛出：
NullPointerException - 如果 seq 为 null。
IndexOutOfBoundsException - 如果 index 为负或大于字符序列的长度，或者如果 codePointOffset 为负并且起始于 index 的子序列拥有的偏移量少于 codePointOffset 代码点，或者 codePointOffset 为负并且 index 前面的子序列的偏移量少于 codePointOffset 代码点的绝对值。
从以下版本开始：
1.5

offsetByCodePoints

public static int offsetByCodePoints(char[]a,
                                     intstart,
                                     intcount,
                                     intindex,
                                     intcodePointOffset)

返回给定 char 子数组中的索引，它是从给定 index 到 codePointOffset 代码点的偏移量。 start 和 count 参数指定了 char 数组的一个子数组。 index 和 codePointOffset 给出的文本范围内的不成对代理项是按一个代码点算作一个项进行计数的。
参数：
a - char 数组
start - 子数组的第一个 char 的索引
count - char 中的子数组的长度
index - 要偏移的索引
codePointOffset - 代码点中的偏移量
返回：
子数组内的索引
抛出：
NullPointerException - 如果 a 为 null。
IndexOutOfBoundsException - 如果存在以下情况： start 或 count 为负； start + count 大于给定数组的长度； index 小于 start 或大于 start + count ； codePointOffset 为负并且起始于 index 、终止于 start + count - 1 的文本字段的偏移量少于 codePointOffset 代码点； codePointOffset 为负并且起始于 start 、终止于 index - 1 的文本字段的偏移量少于 codePointOffset 代码点的绝对值。
从以下版本开始：
1.5

isLowerCase

public static boolean isLowerCase(charch)

确定指定字符是否为小写字母。

如果通过 Character.getType(ch) 提供的字符的常规类别类型为 LOWERCASE_LETTER ，则字符为小写字母。

以下是小写字母的示例：

 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 字符也是小写的。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 isLowerCase(int) 方法。

参数：
ch - 要测试的字符。
返回：
如果字符为小写，则返回 true ；否则返回 false 。
另请参见：
isLowerCase(char) , isTitleCase(char) , toLowerCase(char) , getType(char)

isLowerCase

public static boolean isLowerCase(intcodePoint)

确定指定字符（Unicode 代码点）是否为小写字母。

如果通过 getType(codePoint) 提供的字符的常规类别的类型为 LOWERCASE_LETTER ，则字符为小写字母。

以下是小写字母的示例：

 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(charch)

确定指定字符是否为大写字母。

如果通过 Character.getType(ch) 提供的字符的常规类别类型为 UPPERCASE_LETTER ，则字符为大写字母。

以下是大写字母的示例：

 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 字符也是大写的。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 isUpperCase(int) 方法。

参数：
ch - 要测试的字符。
返回：
如果字符为大写，则返回 true ；否则返回 false 。
从以下版本开始：
1.0
另请参见：
isLowerCase(char) , isTitleCase(char) , toUpperCase(char) , getType(char)

isUpperCase

public static boolean isUpperCase(intcodePoint)

确定指定字符（Unicode 代码点）是否为大写字母。

如果通过 getType(codePoint) 提供的字符的常规类别类型为 UPPERCASE_LETTER ，则字符为大写字母。

以下是大写字母的示例：

 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(charch)

确定指定字符是否为首字母大写字符。

如果通过 Character.getType(ch) 提供的字符的常规类别类型为 TITLECASE_LETTER ，则字符为首字母大写字符。

一些字符看似成对的 Latin 字母。例如，有一个看起来像“LJ”的大写字母和一个看起来像“lj”的对应小写字母。第三种形式看起来像“Lj”，这是呈现首字母大写的小写单词时使用的适当形式，比如用于书籍的标题。

下面是一些可以让该方法返回 true 的 Unicode 字符：

  • 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 字符也是首字母大写的。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 isTitleCase(int) 方法。

参数：
ch - 要测试的字符。
返回：
如果字符为首字母大写，则返回 true ；否则返回 false 。
从以下版本开始：
1.0.2
另请参见：
isLowerCase(char) , isUpperCase(char) , toTitleCase(char) , getType(char)

isTitleCase

public static boolean isTitleCase(intcodePoint)

确定指定字符（Unicode 代码点）是否为首字母大写字符。

如果通过 getType(codePoint) 提供的字符的常规类别类型为 TITLECASE_LETTER ，则字符为首字母大写字符。

一些字符看似成对的 Latin 字母。例如，有一个看起来像“LJ”的大写字母和一个看起来像“lj”的对应小写字母。第三种形式看起来像“Lj”，这是呈现首字母大写的小写单词时使用的适当形式，比如用于书籍的标题。

下面是一些可以让该方法返回 true 的 Unicode 字符：

  • 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 字符也是首字母大写的。

参数：
codePoint - 要测试的字符（Unicode 代码点）。
返回：
如果字符为首字母大写，则返回 true ；否则返回 false 。
从以下版本开始：
1.5
另请参见：
isLowerCase(int) , isUpperCase(int) , toTitleCase(int) , getType(int)

isDigit

public static boolean isDigit(charch)

确定指定字符是否为数字。

如果通过 Character.getType(ch) 提供的字符的常规类别类型为 DECIMAL_DIGIT_NUMBER ，则字符为数字。

包含数字的 Unicode 字符范围：

  • '\u0030' 到 '\u0039' ，ISO-LATIN-1 数字（ '0' 到 '9' ）
  • '\u0660' 到 '\u0669' ，Arabic-Indic 数字
  • '\u06F0' 到 '\u06F9' ，扩展了的 Arabic-Indic 数字
  • '\u0966' 到 '\u096F' ，梵文数字
  • '\uFF10' 到 '\uFF19' ，全形数字

其他许多字符范围也包含数字。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 isDigit(int) 方法。

参数：
ch - 要测试的字符。
返回：
如果字符为数字，则返回 true ；否则返回 false 。
另请参见：
digit(char, int) , forDigit(int, int) , getType(char)

isDigit

public static boolean isDigit(intcodePoint)

确定指定字符（Unicode 代码点）是否为数字。

如果通过 getType(codePoint) 提供的字符的常规类别类型为 DECIMAL_DIGIT_NUMBER ，则字符为数字。

包含数字的 Unicode 字符范围：

  • '\u0030' 到 '\u0039' ，ISO-LATIN-1 数字（ '0' 到 '9' ）
  • '\u0660' 到 '\u0669' ，Arabic-Indic 数字
  • '\u06F0' 到 '\u06F9' ，扩展了的 Arabic-Indic 数字
  • '\u0966' 到 '\u096F' ，梵文数字
  • '\uFF10' 到 '\uFF19' ，全形数字

其他许多字符范围也包含数字。

参数：
codePoint - 要测试的字符（Unicode 代码点）。
返回：
如果字符为数字，则返回 true ；否则返回 false 。
从以下版本开始：
1.5
另请参见：
forDigit(int, int) , getType(int)

isDefined

public static boolean isDefined(charch)

确定指定字符是否被定义为 Unicode 中的字符。

如果以下条件中至少有一个为真，则字符被定义为 Unicode 中的字符：

  • 它具有 UnicodeData 文件中的条目。
  • 它具有 UnicodeData 文件定义的范围中的值。

注：此方法无法处理增补字符。若要支持所有 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(intcodePoint)

确定指定字符（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(charch)

确定指定字符是否为字母。

如果通过 Character.getType(ch) 为字符提供的常规类别的类型为以下类型中的任意一种，则认为该字符为字母：

  • UPPERCASE_LETTER
  • LOWERCASE_LETTER
  • TITLECASE_LETTER
  • MODIFIER_LETTER
  • OTHER_LETTER

并非所有的字母都有大小写。许多字符都是字母，但它们既不是大写的，也不是小写的，并且也不是首字母大写的。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 isLetter(int) 方法。

参数：
ch - 要测试的字符。
返回：
如果字符为字母，则返回 true ；否则返回 false 。
另请参见：
isDigit(char) , isJavaIdentifierStart(char) , isJavaLetter(char) , isJavaLetterOrDigit(char) , isLetterOrDigit(char) , isLowerCase(char) , isTitleCase(char) , isUnicodeIdentifierStart(char) , isUpperCase(char)

isLetter

public static boolean isLetter(intcodePoint)

确定指定字符（Unicode 代码点）是否为字母。

如果通过 getType(codePoint) 为字符提供的常规类别的类型为以下类型中的任意一种，则认为该字符为字母：

  • UPPERCASE_LETTER
  • LOWERCASE_LETTER
  • TITLECASE_LETTER
  • MODIFIER_LETTER
  • OTHER_LETTER

并非所有的字母都有大小写。许多字符都是字母，但它们既不是大写的，也不是小写的，并且也不是首字母大写的。

参数：
codePoint - 要测试的字符（Unicode 代码点）。
返回：
如果字符为字母，则返回 true ；否则返回 false 。
从以下版本开始：
1.5
另请参见：
isDigit(int) , isJavaIdentifierStart(int) , isLetterOrDigit(int) , isLowerCase(int) , isTitleCase(int) , isUnicodeIdentifierStart(int) , isUpperCase(int)

isLetterOrDigit

public static boolean isLetterOrDigit(charch)

确定指定字符是否为字母或数字。

如果 Character.isLetter(char ch) 或 Character.isDigit(char ch) 对字符返回的是 true ，则认为字符是一个字母或数字。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 isLetterOrDigit(int) 方法。

参数：
ch - 要测试的字符。
返回：
如果字符为字符或数字，则返回 true ；否则返回 false 。
从以下版本开始：
1.0.2
另请参见：
isDigit(char) , isJavaIdentifierPart(char) , isJavaLetter(char) , isJavaLetterOrDigit(char) , isLetter(char) , isUnicodeIdentifierPart(char)

isLetterOrDigit

public static boolean isLetterOrDigit(intcodePoint)

确定指定字符（Unicode 代码点）是否字母或数字。

如果 isLetter(codePoint) 或 isDigit(codePoint) 对字符返回的是 true ，则认为字符是一个字母或数字。

参数：
codePoint - 要测试的字符（Unicode 代码点）。
返回：
如果字符为字符或数字，则返回 true ；否则返回 false 。
从以下版本开始：
1.5
另请参见：
isDigit(int) , isJavaIdentifierPart(int) , isLetter(int) , isUnicodeIdentifierPart(int)

isJavaLetter

@Deprecated
public static boolean isJavaLetter(charch)

已过时。用 isJavaIdentifierStart(char) 取代。
确定是否允许将指定字符作为 Java 标识符中的首字符。

当且仅当以下条件之一为真时，字符才可以作为 Java 标识符的首字母：

  • isLetter(ch) 返回 true
  • getType(ch) 返回 LETTER_NUMBER
  • ch 是一个货币符号（如“$”）
  • ch 是一个连字符（如“_”）。
参数：
ch - 要测试的字符。
返回：
如果字符为 Java 标识符的首字符，则返回 true ；否则返回 false 。
从以下版本开始：
1.02
另请参见：
isJavaLetterOrDigit(char) , isJavaIdentifierStart(char) , isJavaIdentifierPart(char) , isLetter(char) , isLetterOrDigit(char) , isUnicodeIdentifierStart(char)

isJavaLetterOrDigit

@Deprecated
public static boolean isJavaLetterOrDigit(charch)

已过时。用 isJavaIdentifierPart(char) 取代。
确定指定字符是否可以是 Java 标识符中首字符以外的部分。

当且仅当以下任何条件为真时，字符才可能是 Java 标识符的一部分：

  • 是一个字母
  • 是一个货币符号（如 '$' ）
  • 是一个连字符（如 '_' ）。
  • 是一个数字
  • 是一个数字字母（如罗马数字字符）
  • 是个合成标记
  • 是一个非空格标记
  • isIdentifierIgnorable 对字符返回的是 true 。
参数：
ch - 要测试的字符。
返回：
如果字符可以为 Java 标识符的一部分，则返回 true ；否则返回 false 。
从以下版本开始：
1.02
另请参见：
isJavaLetter(char) , isJavaIdentifierStart(char) , isJavaIdentifierPart(char) , isLetter(char) , isLetterOrDigit(char) , isUnicodeIdentifierPart(char) , isIdentifierIgnorable(char)

isJavaIdentifierStart

public static boolean isJavaIdentifierStart(charch)

确定是否允许将指定字符作为 Java 标识符中的首字符。

当且仅当以下条件之一为真时，字符才可以作为 Java 标识符的首字符：

  • isLetter(ch) 返回 true
  • getType(ch) 返回 LETTER_NUMBER
  • ch 是一个货币符号（如“$”）
  • ch 是一个连字符（如“_”）。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 isJavaIdentifierStart(int) 方法。

参数：
ch - 要测试的字符。
返回：
如果字符为 Java 标识符的首字符，则返回 true ；否则返回 false 。
从以下版本开始：
1.1
另请参见：
isJavaIdentifierPart(char) , isLetter(char) , isUnicodeIdentifierStart(char)

isJavaIdentifierStart

public static boolean isJavaIdentifierStart(intcodePoint)

确定是否允许将字符（Unicode 代码点）作为 Java 标识符中的首字符。

当且仅当以下条件之一为真时，字符才可以作为 Java 标识符的首字符：

  • isLetter(codePoint) 返回 true
  • getType(codePoint) 返回 LETTER_NUMBER
  • 引用的字符是一个货币符号（如“$”）
  • 引用的字符是一个连字符（如“_”）。
参数：
codePoint - 要测试的字符（Unicode 代码点）。
返回：
如果字符为 Java 标识符的首字符，则返回 true ；否则返回 false 。
从以下版本开始：
1.5
另请参见：
isJavaIdentifierPart(int) , isLetter(int) , isUnicodeIdentifierStart(int)

isJavaIdentifierPart

public static boolean isJavaIdentifierPart(charch)

确定指定字符是否可以是 Java 标识符中首字符以外的部分。

如果以下任何条件为真，那么字符可能是 Java 标识符的一部分：

  • 是一个字母
  • 是一个货币符号（如 '$' ）
  • 是一个连字符（如 '_' ）。
  • 是一个数字
  • 是一个数字字母（如罗马数字字符）
  • 是个合成标记
  • 是一个非空格标记
  • isIdentifierIgnorable 对字符返回的是 true

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 isJavaIdentifierPart(int) 方法。

参数：
ch - 要测试的字符。
返回：
如果字符可以为 Java 标识符的一部分，则返回 true ；否则返回 false 。
从以下版本开始：
1.1
另请参见：
isIdentifierIgnorable(char) , isJavaIdentifierStart(char) , isLetterOrDigit(char) , isUnicodeIdentifierPart(char)

isJavaIdentifierPart

public static boolean isJavaIdentifierPart(intcodePoint)

确定字符（Unicode 代码点）是否可以是 Java 标识符中首字符以外的部分。

如果以下任何条件为真，那么字符可能是 Java 标识符的一部分：

  • 是一个字母
  • 是一个货币符号（如 '$' ）
  • 是一个连字符（如 '_' ）。
  • 是一个数字
  • 是一个数字字母（如罗马数字字符）
  • 是个合成标记
  • 是一个非空格标记
  • isIdentifierIgnorable(codePoint) 对字符返回的是 true
参数：
codePoint - 要测试的字符（Unicode 代码点）。
返回：
如果字符可以为 Java 标识符的一部分，则返回 true ；否则返回 false 。
从以下版本开始：
1.5
另请参见：
isIdentifierIgnorable(int) , isJavaIdentifierStart(int) , isLetterOrDigit(int) , isUnicodeIdentifierPart(int)

isUnicodeIdentifierStart

public static boolean isUnicodeIdentifierStart(charch)

确定是否允许将指定字符作为 Unicode 标识符中的首字符。

当且仅当以下条件之一为真时，字符才可以作为 Unicode 标识符的首字符：

  • isLetter(ch) 返回 true
  • getType(ch) 返回 LETTER_NUMBER 。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 isUnicodeIdentifierStart(int) 方法。

参数：
ch - 要测试的字符。
返回：
如果字符可以作为 Unicode 标识符的首字符，则返回 true ；否则返回 false 。
从以下版本开始：
1.1
另请参见：
isJavaIdentifierStart(char) , isLetter(char) , isUnicodeIdentifierPart(char)

isUnicodeIdentifierStart

public static boolean isUnicodeIdentifierStart(intcodePoint)

确定是否允许将指定字符（Unicode 代码点）作为 Unicode 标识符中的首字符。

当且仅当以下条件之一为真时，字符才可以作为 Unicode 标识符的首字符：

  • isLetter(codePoint) 返回 true
  • getType(codePoint) 返回 LETTER_NUMBER 。
参数：
codePoint - 要测试的字符（Unicode 代码点）。
返回：
如果字符可以作为 Unicode 标识符的首字符，则返回 true ；否则返回 false 。
从以下版本开始：
1.5
另请参见：
isJavaIdentifierStart(int) , isLetter(int) , isUnicodeIdentifierPart(int)

isUnicodeIdentifierPart

public static boolean isUnicodeIdentifierPart(charch)

确定指定字符是否可以是 Unicode 标识符中首字符以外的部分。

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

  • 是一个字母
  • 是一个连字符（如 '_' ）。
  • 是一个数字
  • 是一个数字字母（如罗马数字字符）
  • 是个合成标记
  • 是一个非空格标记
  • isIdentifierIgnorable 对该字符返回的是 true 。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 isUnicodeIdentifierPart(int) 方法。

参数：
ch - 要测试的字符。
返回：
如果字符可以为 Unicode 标识符的一部分，则返回 true ；否则返回 false 。
从以下版本开始：
1.1
另请参见：
isIdentifierIgnorable(char) , isJavaIdentifierPart(char) , isLetterOrDigit(char) , isUnicodeIdentifierStart(char)

isUnicodeIdentifierPart

public static boolean isUnicodeIdentifierPart(intcodePoint)

确定指定字符（Unicode 代码点）是否可以是 Unicode 标识符中首字符以外的部分。

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

  • 是一个字母
  • 是一个连字符（如 '_' ）。
  • 是一个数字
  • 是一个数字字母（如罗马数字字符）
  • 是个合成标记
  • 是一个非空格标记
  • isIdentifierIgnorable 对该字符返回的是 true 。
参数：
codePoint - 要测试的字符（Unicode 代码点）。
返回：
如果字符可以为 Unicode 标识符的一部分，则返回 true ；否则返回 false 。
从以下版本开始：
1.5
另请参见：
isIdentifierIgnorable(int) , isJavaIdentifierPart(int) , isLetterOrDigit(int) , isUnicodeIdentifierStart(int)

isIdentifierIgnorable

public static boolean isIdentifierIgnorable(charch)

确定是否应该认为指定字符是 Java 标识符或 Unicode 标识符中可忽略的一个字符。

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

  • 非空白的 ISO 控制字符
    • '\u0000' 到 '\u0008'
    • '\u000E' 到 '\u001B'
    • '\u007F' 到 '\u009F'
  • 拥有 FORMAT 常规类别值的所有字符

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 isIdentifierIgnorable(int) 方法。

参数：
ch - 要测试的字符。
返回：
如果字符是可以成为 Java 或 Unicode 标识符的一部分的可忽略控制字符，则返回 true ；否则返回 false 。
从以下版本开始：
1.1
另请参见：
isJavaIdentifierPart(char) , isUnicodeIdentifierPart(char)

isIdentifierIgnorable

public static boolean isIdentifierIgnorable(intcodePoint)

确定是否应该认为指定字符（Unicode 代码点）是 Java 标识符或 Unicode 标识符中可忽略的一个字符。

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

  • 非空白的 ISO 控制字符
    • '\u0000' 到 '\u0008'
    • '\u000E' 到 '\u001B'
    • '\u007F' 到 '\u009F'
  • 拥有 FORMAT 常规类别值的所有字符
参数：
codePoint - 要测试的字符（Unicode 代码点）。
返回：
如果字符是可以成为 Java 或 Unicode 标识符的一部分的可忽略控制字符，则返回 true ；否则返回 false 。
从以下版本开始：
1.5
另请参见：
isJavaIdentifierPart(int) , isUnicodeIdentifierPart(int)

toLowerCase

public static char toLowerCase(charch)

使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为小写。

注意，对于某些范围内的字符，特别是那些是符号或表意符号的字符， Character.isLowerCase(Character.toLowerCase(ch)) 并不总是返回 true 。

通常，应该使用 String.toLowerCase() 将字符映射为小写。 String 大小写映射方法有几个胜过 Character 大小写映射方法的优点。 String 大小写映射方法可以执行语言环境敏感的映射、上下文敏感的映射和 1:M 字符映射，而 Character 大小写映射方法却不能。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 toLowerCase(int) 方法。

参数：
ch - 要转换的字符。
返回：
等效于字符的小写形式，如果有的话；否则返回字符本身。
另请参见：
isLowerCase(char) , String.toLowerCase()

toLowerCase

public static int toLowerCase(intcodePoint)

使用来自 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(charch)

使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为大写。

注意，对于某些范围内的字符，特别是那些是符号或表意符号的字符， Character.isUpperCase(Character.toUpperCase(ch)) 并不总是返回 true 。

通常，应该使用 String.toUpperCase() 将字符映射为大写。 String 大小写映射方法有几个胜过 Character 大小写映射方法的优点。 String 大小写映射方法可以执行语言环境敏感的映射、上下文敏感的映射和 1:M 字符映射，而 Character 大小写映射方法却不能。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 toUpperCase(int) 方法。

参数：
ch - 要转换的字符。
返回：
等效于字符的大写形式，如果有的话；否则返回字符本身。
另请参见：
isUpperCase(char) , String.toUpperCase()

toUpperCase

public static int toUpperCase(intcodePoint)

使用来自 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(charch)

使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为首字母大写。如果字符没有明确的首字母大写映射，并且根据 UnicodeData，它本身并不是一个首字母大写的 char，则返回大写映射作为等效的首字母大写映射。如果 char 参数总是一个首字母大写的 char ，则返回相同的 char 值。

注意，对于某些范围内的字符， Character.isTitleCase(Character.toTitleCase(ch)) 并不总是返回 true 。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 toTitleCase(int) 方法。

参数：
ch - 要转换的字符。
返回：
如果有的话，则返回等效于字符的首字母大写形式；否则返回字符本身。
从以下版本开始：
1.0.2
另请参见：
isTitleCase(char) , toLowerCase(char) , toUpperCase(char)

toTitleCase

public static int toTitleCase(intcodePoint)

使用来自 UnicodeData 文件的大小写映射信息将字符（Unicode 代码点）参数转换为首字母大写。如果字符没有明确的首字母大写映射，并且根据 UnicodeData，它本身并不是一个首字母大写的 char，则返回大写映射作为等效的首字母大写映射。如果字符参数总是一个首字母大写的字符，则返回相同的字符值。

注意，对于某些范围内的字符， Character.isTitleCase(Character.toTitleCase(codePoint)) 并不总是返回 true 。

参数：
codePoint - 要转换的字符（Unicode 代码点）。
返回：
如果有的话，则返回等效于字符的首字母大写形式；否则返回字符本身。
从以下版本开始：
1.5
另请参见：
isTitleCase(int) , toLowerCase(int) , toUpperCase(int)

digit

public static int digit(charch,
                        intradix)

返回使用指定基数的字符 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 。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 digit(int, int) 方法。

参数：
ch - 要转换的字符。
radix - 基数。
返回：
使用指定基数的字符所表示的数值。
另请参见：
forDigit(int, int) , isDigit(char)

digit

public static int digit(intcodePoint,
                        intradix)

返回使用指定基数的指定字符（Unicode 代码点）的数值。

如果基数不在 MIN_RADIX <= radix <= MAX_RADIX 范围之内，或者如果字符是一个使用指定基数的无效数字，则返回 -1 。如果以下条件中至少有一个为真，则字符是一个有效数字：

  • 方法 isDigit(codePoint) 为 true ，且字符（或分解的单字符）的 Unicode 十进制数值小于指定的基数。在这种情况下，返回十进制数值。
  • 字符为 'A' 到 'Z' 范围内的大写拉丁字母之一，且它的代码小于 radix + 'A' - 10 。在这种情况下，返回 ch - 'A' + 10 。
  • 字符为 'a' 到 'z' 范围内的小写拉丁字母之一，且它的代码小于 radix + 'a' - 10 。在这种情况下，返回 ch - 'a' + 10 。
参数：
codePoint - 要转换的字符（Unicode 代码点）。
radix - 基数。
返回：
使用指定基数的字符所表示的数值。
从以下版本开始：
1.5
另请参见：
forDigit(int, int) , isDigit(int)

getNumericValue

public static int getNumericValue(charch)

返回指定的 Unicode 字符表示的 int 值。例如，字符 '\u216C' （罗马数字 50）将返回一个值为 50 的整数。

字母 A-Z 的大写（ '\u0041' 到 '\u005A' ）、小写（ '\u0061' 到 '\u007A' ）和全形参数（ '\uFF21' 到 '\uFF3A' 和 '\uFF41' 到 '\uFF5A' ）形式拥有从 10 到 35 的数值。这独立于 Unicode 规范，该规范没有为这些 char 值分配数值。

如果字符中没有数值，则返回 -1。如果字符中有一个数值，但无法将它表示为非负整数（例如，小数值），则返回 -2。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 getNumericValue(int) 方法。

参数：
ch - 要转换的字符。
返回：
以非负 int 值形式返回字符的数值；如果字符中有一个不是非负整数的数值，则返回 -2；如果字符中没有数值，则返回 -1。
从以下版本开始：
1.1
另请参见：
forDigit(int, int) , isDigit(char)

getNumericValue

public static int getNumericValue(intcodePoint)

返回指定字符（Unicode 代码点）表示的 int 值。例如，字符 '\u216C' （罗马数字 50）将返回一个值为 50 的 int 值。

字母 A-Z 的大写（ '\u0041' 到 '\u005A' ）、小写（ '\u0061' 到 '\u007A' ）和全形参数（ '\uFF21' 到 '\uFF3A' 和 '\uFF41' 到 '\uFF5A' ）形式拥有从 10 到 35 的数值。这独立于 Unicode 规范，该规范没有为这些 char 值分配数值。

如果字符中没有数字值，则返回 -1。如果字符中有一个数值，但无法将它表示为非负整数（例如，小数值），则返回 -2。

参数：
codePoint - 要转换的字符（Unicode 代码点）。
返回：
以非负 int 值形式返回字符的数值；如果字符中有一个不是非负整数的数值，则返回 -2；如果字符中没有数值，则返回 -1。
从以下版本开始：
1.5
另请参见：
forDigit(int, int) , isDigit(int)

isSpace

@Deprecated
public static boolean isSpace(charch)

已过时。用 isWhitespace(char) 取代。
确定指定字符是否为 ISO-LATIN-1 空白。该方法只对以下五个字符返回 true ：
'\t''\u0009'HORIZONTAL TABULATION
'\n''\u000A'NEW LINE
'\f''\u000C'FORM FEED
'\r''\u000D'CARRIAGE RETURN
'''\u0020'SPACE
参数：
ch - 要测试的字符。
返回：
如果字符为 ISO-LATIN-1 空白，则返回 true ；否则返回 false 。
另请参见：
isSpaceChar(char) , isWhitespace(char)

isSpaceChar

public static boolean isSpaceChar(charch)

确定指定字符是否为 Unicode 空白字符。当且仅当根据 Unicode 标准将字符指定为空白字符时，才认为字符是一个空白字符。如果字符的常规类别的类型为以下类型中的任意一种，则该方法返回 true：
  • SPACE_SEPARATOR
  • LINE_SEPARATOR
  • PARAGRAPH_SEPARATOR

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 isSpaceChar(int) 方法。

参数：
ch - 要测试的字符。
返回：
如果字符为空白字符，则返回 true ；否则返回 false 。
从以下版本开始：
1.1
另请参见：
isWhitespace(char)

isSpaceChar

public static boolean isSpaceChar(intcodePoint)

确定指定字符（Unicode 代码点）是否为 Unicode 空白字符。当且仅当根据 Unicode 标准将字符指定为空白字符时，才认为字符是一个空白字符。如果字符的常规类别的类型为以下类型中的任意一种，则该方法返回 true：
  • SPACE_SEPARATOR
  • LINE_SEPARATOR
  • PARAGRAPH_SEPARATOR
参数：
codePoint - 要测试的字符（Unicode 代码点）。
返回：
如果字符为空白字符，则返回 true ；否则返回 false 。
从以下版本开始：
1.5
另请参见：
isWhitespace(int)

isWhitespace

public static boolean isWhitespace(charch)

确定指定字符依据 Java 标准是否为空白字符。当且仅当字符满足以下标准时，该字符才是一个 Java 空白字符：
  • 它是 Unicode 空格字符（ SPACE_SEPARATOR 、 LINE_SEPARATOR 或 PARAGRAPH_SEPARATOR )，但不是非中断空格（ '\u00A0' 、 '\u2007' 、 '\u202F' ）
  • 它是 '\u0009' ，HORIZONTAL TABULATION
  • 它是 '\u000A' ，LINE FEED
  • 它是 '\u000B' ，VERTICAL TABULATION
  • 它是 '\u000C' ，FORM FEED
  • 它是 '\u000D' ，CARRIAGE RETURN
  • 它是 '\u001C' ，FILE SEPARATOR
  • 它是 '\u001D' ，GROUP SEPARATOR
  • 它是 '\u001E' ，RECORD SEPARATOR
  • 它是 '\u001F' ，UNIT SEPARATOR

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 isWhitespace(int) 方法。

参数：
ch - 要测试的字符。
返回：
如果字符为 Java 空白字符，则返回 true ；否则返回 false 。
从以下版本开始：
1.1
另请参见：
isSpaceChar(char)

isWhitespace

public static boolean isWhitespace(intcodePoint)

确定指定字符（Unicode 代码点）依据 Java 标准是否为空白字符。当且仅当字符满足以下标准时，该字符才是一个 Java 空白字符：
  • 它是一个 Unicode 空白字符（ SPACE_SEPARATOR 、 LINE_SEPARATOR 或 PARAGRAPH_SEPARATOR ），但不是一个不间断空格（ '\u00A0' 、 '\u2007' 和 '\u202F' ）。
  • '\u0009' ，水平制表符。
  • '\u000A' ，换行。
  • '\u000B' ，纵向制表符。
  • '\u000C' ，换页。
  • '\u000D' ，回车。
  • '\u001C' ，文件分隔符。
  • '\u001D' ，组分隔符。
  • '\u001E' ，记录分隔符。
  • '\u001F' ，单元分隔符。
参数：
codePoint - 要测试的字符（Unicode 代码点）。
返回：
如果字符为 Java 空白字符，则返回 true ；否则返回 false 。
从以下版本开始：
1.5
另请参见：
isSpaceChar(int)

isISOControl

public static boolean isISOControl(charch)

确定指定字符是否为 ISO 控制字符。如果字符的代码在从 '\u0000' 到 '\u001F' 或从 '\u007F' 到 '\u009F' 的范围内，则认为该字符是一个 ISO 控制字符。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 isISOControl(int) 方法。

参数：
ch - 要测试的字符。
返回：
如果字符为 ISO 控制字符，则返回 true ；否则返回 false 。
从以下版本开始：
1.1
另请参见：
isSpaceChar(char) , isWhitespace(char)

isISOControl

public static boolean isISOControl(intcodePoint)

确定引用的字符（Unicode 代码点）是否 ISO 控制字符。如果字符的代码在从 '\u0000' 到 '\u001F' 或从 '\u007F' 到 '\u009F' 的范围内，则认为该字符是一个 ISO 控制字符。
参数：
codePoint - 要测试的字符（Unicode 代码点）。
返回：
如果字符为 ISO 控制字符，则返回 true ；否则返回 false 。
从以下版本开始：
1.5
另请参见：
isSpaceChar(int) , isWhitespace(int)

getType

public static int getType(charch)

返回一个指示字符的常规类别的值。

注： 此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 getType(int) 方法。

参数：
ch - 要测试的字符。
返回：
表示字符的常规类别的 int 类型的值。
从以下版本开始：
1.1
另请参见：
COMBINING_SPACING_MARK , CONNECTOR_PUNCTUATION , CONTROL , CURRENCY_SYMBOL , DASH_PUNCTUATION , DECIMAL_DIGIT_NUMBER , ENCLOSING_MARK , END_PUNCTUATION , FINAL_QUOTE_PUNCTUATION , FORMAT , INITIAL_QUOTE_PUNCTUATION , LETTER_NUMBER , LINE_SEPARATOR , LOWERCASE_LETTER , MATH_SYMBOL , MODIFIER_LETTER , MODIFIER_SYMBOL , NON_SPACING_MARK , OTHER_LETTER , OTHER_NUMBER , OTHER_PUNCTUATION , OTHER_SYMBOL , PARAGRAPH_SEPARATOR , PRIVATE_USE , SPACE_SEPARATOR , START_PUNCTUATION , SURROGATE , TITLECASE_LETTER , UNASSIGNED , UPPERCASE_LETTER

getType

public static int getType(intcodePoint)

返回一个指示字符的常规类别的值。
参数：
codePoint - 要测试的字符（Unicode 代码点）。
返回：
表示字符的常规类别的 int 类型的值。
从以下版本开始：
1.5
另请参见：
COMBINING_SPACING_MARK , CONNECTOR_PUNCTUATION , CONTROL , CURRENCY_SYMBOL , DASH_PUNCTUATION , DECIMAL_DIGIT_NUMBER , ENCLOSING_MARK , END_PUNCTUATION , FINAL_QUOTE_PUNCTUATION , FORMAT , INITIAL_QUOTE_PUNCTUATION , LETTER_NUMBER , LINE_SEPARATOR , LOWERCASE_LETTER , MATH_SYMBOL , MODIFIER_LETTER , MODIFIER_SYMBOL , NON_SPACING_MARK , OTHER_LETTER , OTHER_NUMBER , OTHER_PUNCTUATION , OTHER_SYMBOL , PARAGRAPH_SEPARATOR , PRIVATE_USE , SPACE_SEPARATOR , START_PUNCTUATION , SURROGATE , TITLECASE_LETTER , UNASSIGNED , UPPERCASE_LETTER

forDigit

public static char forDigit(intdigit,
                            intradix)

确定使用指定基数的特定数字的字符表示形式。如果 radix 的值不是一个有效基数，或者 digit 的值不是一个使用指定基数的有效数字，则返回 null 字符（ '\u0000' ）。

如果 radix 参数大于或等于 MIN_RADIX 并且小于或等于 MAX_RADIX ，则该参数是有效的。如果 0<=digit<radix ，则 digit 参数是有效的。

如果数字小于 10，则返回 '0'+ digit 。否则，返回的值为 'a'+ digit-10 。

参数：
digit - 转换为字符的数字。
radix - 基数。
返回：
使用指定基数的指定数字的 char 表示形式。
另请参见：
MIN_RADIX , MAX_RADIX , digit(char, int)

getDirectionality

public static byte getDirectionality(charch)

返回给定字符的 Unicode 方向属性。利用字符方向性来计算文本的视觉顺序。未定义的 char 值的方向值是 DIRECTIONALITY_UNDEFINED 。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 getDirectionality(int) 方法。

参数：
ch - 为其请求方向属性的 char 。
返回：
char 值的方向属性。
从以下版本开始：
1.4
另请参见：
DIRECTIONALITY_UNDEFINED , DIRECTIONALITY_LEFT_TO_RIGHT , DIRECTIONALITY_RIGHT_TO_LEFT , DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC , DIRECTIONALITY_EUROPEAN_NUMBER , DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR , DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR , DIRECTIONALITY_ARABIC_NUMBER , DIRECTIONALITY_COMMON_NUMBER_SEPARATOR , DIRECTIONALITY_NONSPACING_MARK , DIRECTIONALITY_BOUNDARY_NEUTRAL , DIRECTIONALITY_PARAGRAPH_SEPARATOR , DIRECTIONALITY_SEGMENT_SEPARATOR , DIRECTIONALITY_WHITESPACE , DIRECTIONALITY_OTHER_NEUTRALS , DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING , DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE , DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING , DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE , DIRECTIONALITY_POP_DIRECTIONAL_FORMAT

getDirectionality

public static byte getDirectionality(intcodePoint)

返回给定字符（Unicode 代码点）的 Unicode 方向属性。利用字符方向性来计算文本的视觉顺序。未定义字符的方向值是 DIRECTIONALITY_UNDEFINED 。
参数：
codePoint - 为其请求方向属性 * 的字符（Unicode 代码点）。
返回：
字符的方向属性。
从以下版本开始：
1.5
另请参见：
DIRECTIONALITY_UNDEFINED , DIRECTIONALITY_LEFT_TO_RIGHT , DIRECTIONALITY_RIGHT_TO_LEFT , DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC , DIRECTIONALITY_EUROPEAN_NUMBER , DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR , DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR , DIRECTIONALITY_ARABIC_NUMBER , DIRECTIONALITY_COMMON_NUMBER_SEPARATOR , DIRECTIONALITY_NONSPACING_MARK , DIRECTIONALITY_BOUNDARY_NEUTRAL , DIRECTIONALITY_PARAGRAPH_SEPARATOR , DIRECTIONALITY_SEGMENT_SEPARATOR , DIRECTIONALITY_WHITESPACE , DIRECTIONALITY_OTHER_NEUTRALS , DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING , DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE , DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING , DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE , DIRECTIONALITY_POP_DIRECTIONAL_FORMAT

isMirrored

public static boolean isMirrored(charch)

确定指定字符依据 Unicode 规范是否对称。当显示在以从右至左的方式显示的文本中时，对称字符的字形在水平方向上应该是对称的。例如， '\u0028' LEFT PARENTHESIS 在语义上被定义为是开括号。在从左至右显示的文本中，它将显示为“(”，但在以从右至左的方式显示的文本中，它显示为“)”。

注：此方法无法处理增补字符。若要支持所有 Unicode 字符，包括增补字符，请使用 isMirrored(int) 方法。

参数：
ch - 为其请求对称属性的 char
返回：
如果字符是对称的，则返回 true ，如果 char 不是对称的或者尚未定义，则返回 false 。
从以下版本开始：
1.4

isMirrored

public static boolean isMirrored(intcodePoint)

确定指定字符（Unicode 代码点）依据 Unicode 规范是否对称。当显示在以从右至左的方式显示的文本中时，对称字符的字形在水平方向上应该是对称的。例如， '\u0028' LEFT PARENTHESIS 在语义上被定义为是开括号。在从左至右显示的文本中，它将显示为“(”，但在以从右至左的方式显示的文本中，它显示为“)”。
参数：
codePoint - 要测试的字符（Unicode 代码点）。
返回：
如果字符是对称的，则返回 true ，如果字符是不对称的或者尚未定义，则返回 false 。
从以下版本开始：
1.5

compareTo

public int compareTo(CharacteranotherCharacter)

根据数字比较两个 Character 对象。
指定者：
接口 Comparable<Character> 中的 compareTo
参数：
anotherCharacter - 要比较的 Character 。
返回：
如果该 Character 等于此 Character ，则返回 0 ；如果该 Character 的数值小于参数 Character ，则返回小于 0 的值；如果该 Character 的数值大于参数 Character ，则返回大于 0 的值（有符号比较）。注意，这是一次严格的数字比较；它并不依赖于区域。
从以下版本开始：
1.2

reverseBytes

public static char reverseBytes(charch)

返回通过反转指定 char 值中的字节顺序而获得的值。
返回：
通过反转（或者等效于交换）指定 char 值中的字节而获得的值。
从以下版本开始：
1.5

如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论， 你可以免费 注册 一个本站的账号。
列表为空，暂无数据
    我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站，即表示您同意使用 Cookies 和您的相关数据。
    原文