概述  软件包   类  使用  树  已过时  索引  帮助 
JavaTM 2 Platform
Standard Ed. 5.0
 上一个类   下一个类 框架    无框架    
摘要： 嵌套 | 字段 | 构造方法 | 方法 详细信息： 字段 | 构造方法 | 方法

java.lang
类 Character

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

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

此外，该类提供了一些方法，用来确定字符的类别（小写字母，数字等等），以及实现字符的大小写转换。

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

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

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

Unicode 字符表示形式

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 值有关的行为如下：

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

从以下版本开始：
1.0
另请参见：
序列化表格

嵌套类摘要
static class Character.Subset
          此类的实例表示 Unicode 字符集的特定子集。
static class Character.UnicodeBlock
          表示 Unicode 规范中字符块的一系列字符子集。
 
字段摘要
static byte COMBINING_SPACING_MARK
          Unicode 规范中的常规类别“Mc”。
static byte CONNECTOR_PUNCTUATION
          Unicode 规范中的常规类别“Pc”。
static byte CONTROL
          Unicode 规范中的常规类别“Cc”。
static byte CURRENCY_SYMBOL
          Unicode 规范中的常规类别“Sc”。
static byte DASH_PUNCTUATION
          Unicode 规范中的常规类别“Pd”。
static byte DECIMAL_DIGIT_NUMBER
          Unicode 规范中的常规类别“Nd”。
static byte DIRECTIONALITY_ARABIC_NUMBER
          Unicode 规范中的弱双向字符类型“AN”。
static byte DIRECTIONALITY_BOUNDARY_NEUTRAL
          Unicode 规范中的弱双向字符类型“BN”。
static byte DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
          Unicode 规范中的弱双向字符类型“CS”。
static byte DIRECTIONALITY_EUROPEAN_NUMBER
          Unicode 规范中的弱双向字符类型“EN”。
static byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
          Unicode 规范中的弱双向字符类型“ES”。
static byte DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
          Unicode 规范中的弱双向字符类型“ET”。
static byte DIRECTIONALITY_LEFT_TO_RIGHT
          Unicode 规范中的强双向字符类型“L”。
static byte DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
          Unicode 规范中的强双向字符类型“LRE”。
static byte DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
          Unicode 规范中的强双向字符类型“LRO”。
static byte DIRECTIONALITY_NONSPACING_MARK
          Unicode 规范中的弱双向字符类型“NSM”。
static byte DIRECTIONALITY_OTHER_NEUTRALS
          Unicode 规范中的非特定双向字符类型“ON”。
static byte DIRECTIONALITY_PARAGRAPH_SEPARATOR
          Unicode 规范中的非特定双向字符类型“B”。
static byte DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
          Unicode 规范中的弱双向字符类型“PDF”。
static byte DIRECTIONALITY_RIGHT_TO_LEFT
          Unicode 规范中的强双向字符类型“R”。
static byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
          Unicode 规范中的强双向字符类型“AL”。
static byte DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
          Unicode 规范中的强双向字符类型“RLE”。
static byte DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
          Unicode 规范中的强双向字符类型“RLO”。
static byte DIRECTIONALITY_SEGMENT_SEPARATOR
          Unicode 规范中的非特定双向字符类型“S”。
static byte DIRECTIONALITY_UNDEFINED
          未定义的双向字符类型。
static byte DIRECTIONALITY_WHITESPACE
          Unicode 规范中的非特定双向字符类型“WS”。
static byte ENCLOSING_MARK
          Unicode 规范中的常规类别“Me”。
static byte END_PUNCTUATION
          Unicode 规范中的常规类别“Pe”。
static byte FINAL_QUOTE_PUNCTUATION
          Unicode 规范中的常规类别“Pf”。
static byte FORMAT
          Unicode 规范中的常规类别“Cf”。
static byte INITIAL_QUOTE_PUNCTUATION
          Unicode 规范中的常规类别“Pi”。
static byte LETTER_NUMBER
          Unicode 规范中的常规类别“Nl”。
static byte LINE_SEPARATOR
          Unicode 规范中的常规类别“Zl”。
static byte LOWERCASE_LETTER
          Unicode 规范中的常规类别“Ll”。
static byte MATH_SYMBOL
          Unicode 规范中的常规类别“Sm”。
static int MAX_CODE_POINT
          Unicode 代码点的最大值。
static char MAX_HIGH_SURROGATE
          UTF-16 编码中的 Unicode 高代理项代码单元的最大值。
static char MAX_LOW_SURROGATE
          UTF-16 编码中的 Unicode 低代理项代码单元的最大值。
static int MAX_RADIX
          可用于与字符串相互转换的最大基数。
static char MAX_SURROGATE
          UTF-16 编码中的 Unicode 代理项代码单元的最大值。
static char MAX_VALUE
          此字段的常量值是 char 类型的最大值，即 '\uFFFF'。
static int MIN_CODE_POINT
          Unicode 代码点的最小值。
static char MIN_HIGH_SURROGATE
          UTF-16 编码中的 Unicode 高代理项代码单元的最小值。
static char MIN_LOW_SURROGATE
          UTF-16 编码中的 Unicode 低代理项代码单元的最小值。
static int MIN_RADIX
          可用于与字符串相互转换的最小基数。
static int MIN_SUPPLEMENTARY_CODE_POINT
          增补代码点的最小值。
static char MIN_SURROGATE
          UTF-16 编码中的 Unicode 代理项代码单元的最小值。
static char MIN_VALUE
          此字段的常量值是 char 类型的最小值，即 '\u0000'。
static byte MODIFIER_LETTER
          Unicode 规范中的常规类别“Lm”。
static byte MODIFIER_SYMBOL
          Unicode 规范中的常规类别“Sk”。
static byte NON_SPACING_MARK
          Unicode 规范中的常规类别“Mn”。
static byte OTHER_LETTER
          Unicode 规范中的常规类别“Lo”。
static byte OTHER_NUMBER
          Unicode 规范中的常规类别“No”。
static byte OTHER_PUNCTUATION
          Unicode 规范中的常规类别“Po”。
static byte OTHER_SYMBOL
          Unicode 规范中的常规类别“So”。
static byte PARAGRAPH_SEPARATOR
          Unicode 规范中的常规类别“Zp”。
static byte PRIVATE_USE
          Unicode 规范中的常规类别“Co”。
static int SIZE
          用来以无符号二进制形式表示 char 值的位数。
static byte SPACE_SEPARATOR
          Unicode 规范中的常规类别“Zs”。
static byte START_PUNCTUATION
          Unicode 规范中的常规类别“Ps”。
static byte SURROGATE
          Unicode 规范中的常规类别“Cs”。
static byte TITLECASE_LETTER
          Unicode 规范中的常规类别“Lt”。
static Class<Character> TYPE
          表示基本类型 char 的 Class 实例。
static byte UNASSIGNED
          Unicode 规范中的常规类别“Cn”。
static byte UPPERCASE_LETTER
          Unicode 规范中的常规类别“Lu”。
 
构造方法摘要
Character(char value)
          构造一个新分配的 Character 对象，用以表示指定的 char 值。
 
方法摘要
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 数组的给定索引上的代码点，该数组中只有那些具有小于 limit 的 index 值的数组元素可以使用。
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 数组的给定索引前面的代码点，该数组中只有那些具有大于或等于 start 的 index 值的数组元素可以使用。
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 代码点数量。
 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 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 的哈希代码。
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 值是否为一个高代理项代码单元（也称为前导代理项代码单元）。
static boolean isIdentifierIgnorable(char ch)
          确定是否应该认为指定字符是 Java 标识符或 Unicode 标识符中可忽略的一个字符。
static boolean isIdentifierIgnorable(int codePoint)
          确定是否应该认为指定字符（Unicode 代码点）是 Java 标识符或 Unicode 标识符中可忽略的一个字符。
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 值是否一个低代理项代码单元（也称为尾部代理项代码单元）。
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 代码点）是否在增补字符范围内。
static boolean isSurrogatePair(char high, char low)
          确定指定的 char 值对是否为有效的代理项对。
static boolean isTitleCase(char ch)
          确定指定字符是否为首字母大写字符。
static boolean isTitleCase(int codePoint)
          确定指定字符（Unicode 代码点）是否为首字母大写字符。
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)
          确定指定的代码点是否为从 0x0000 到 0x10FFFF 范围之内的有效 Unicode 代码点值。
static boolean isWhitespace(char ch)
          确定指定字符依据 Java 标准是否为空白字符。
static boolean isWhitespace(int codePoint)
          确定指定字符（Unicode 代码点）依据 Java 标准是否为空白字符。
static int offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset)
          返回给定 char 子数组中的索引，它是从给定 index 到 codePointOffset 代码点的偏移量。
static int offsetByCodePoints(CharSequence seq, int index, int codePointOffset)
          返回给定字符序列中的索引，它是从给定 index 到 codePointOffset 代码点的偏移量。
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)
          返回表示指定 char 值的 String 对象。
static char toTitleCase(char ch)
          使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为首字母大写。
static int toTitleCase(int codePoint)
          使用来自 UnicodeData 文件的大小写映射信息将字符（Unicode 代码点）参数转换为首字母大写。
static char toUpperCase(char ch)
          使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为大写。
static int toUpperCase(int codePoint)
          使用来自 UnicodeData 文件的大小写映射信息将字符（Unicode 代码点）参数转换为大写。
static Character valueOf(char c)
          返回表示指定 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(char value)
构造一个新分配的 Character 对象，用以表示指定的 char 值。

参数：
value - Character 对象表示的值。
方法详细信息

valueOf

public static Character valueOf(char c)
返回表示指定 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(Object obj)
将此对象与指定对象比较。当且仅当参数不是 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(char c)
返回表示指定 char 值的 String 对象。结果是长度为 1 的字符串，仅由指定的 char 组成。

参数：
c - 要转换的 char 值
返回：
指定 char 值的字符串表示形式
从以下版本开始：
1.4

isValidCodePoint

public static boolean isValidCodePoint(int codePoint)
确定指定的代码点是否为从 0x0000 到 0x10FFFF 范围之内的有效 Unicode 代码点值。该方法等效于以下表达式： 
 codePoint >= 0x0000 && codePoint <= 0x10FFFF

参数：
codePoint - 要测试的 Unicode 代码点
返回：
如果指定的代码点值是一个有效的代码点值，则返回 true；否则返回 false。
从以下版本开始：
1.5

isSupplementaryCodePoint

public static boolean isSupplementaryCodePoint(int codePoint)
确定指定字符（Unicode 代码点）是否在增补字符范围内。该方法等效于以下表达式： 
 codePoint >= 0x10000 && codePoint <= 0x10ffff

参数：
codePoint - 要测试的字符（Unicode 代码点）
返回：
如果指定字符在 Unicode 增补字符范围内，则返回 true；否则返回 false。
从以下版本开始：
1.5

isHighSurrogate

public static boolean isHighSurrogate(char ch)
确定给出的 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(char ch)
确定给定 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(char high,
                                      char low)
确定指定的 char 值对是否为有效的代理项对。该方法等效于以下表达式： 
 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 - 高代理项代码单元
low - 低代理项代码单元
返回：
用指定代理项对组成的增补代码点
从以下版本开始：
1.5

codePointAt

public static int codePointAt(CharSequence seq,
                              int index)
返回 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,
                              int index)
返回 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,
                              int index,
                              int limit)
返回 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(CharSequence seq,
                                  int index)
返回 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,
                                  int index)
返回 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,
                                  int index,
                                  int start)
返回 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(int codePoint,
                          char[] dst,
                          int dstIndex)
将指定字符（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(int codePoint)
将指定的字符（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(CharSequence seq,
                                 int beginIndex,
                                 int endIndex)
返回指定字符序列的文本范围内的 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,
                                 int offset,
                                 int count)
返回 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(CharSequence seq,
                                     int index,
                                     int codePointOffset)
返回给定字符序列中的索引，它是从给定 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,
                                     int start,
                                     int count,
                                     int index,
                                     int codePointOffset)
返回给定 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(char ch)
确定指定字符是否为小写字母。

如果通过 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(int codePoint)
确定指定字符（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(char ch)
确定指定字符是否为大写字母。

如果通过 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(int codePoint)
确定指定字符（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(char ch)
确定指定字符是否为首字母大写字符。

如果通过 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(int codePoint)
确定指定字符（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(char ch)
确定指定字符是否为数字。

如果通过 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(int codePoint)
确定指定字符（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(char ch)
确定指定字符是否被定义为 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(int codePoint)
确定指定字符（Unicode 代码点）是否被定义为 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(char ch)
确定指定字符是否为字母。

如果通过 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(int codePoint)
确定指定字符（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(char ch)
确定指定字符是否为字母或数字。

如果 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(int codePoint)
确定指定字符（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(char ch)
已过时。 用 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(char ch)
已过时。 用 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(char ch)
确定是否允许将指定字符作为 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(int codePoint)
确定是否允许将字符（Unicode 代码点）作为 Java 标识符中的首字符。

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

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

isJavaIdentifierPart

public static boolean isJavaIdentifierPart(char ch)
确定指定字符是否可以是 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(int codePoint)
确定字符（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(char ch)
确定是否允许将指定字符作为 Unicode 标识符中的首字符。

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

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

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

isUnicodeIdentifierStart

public static boolean isUnicodeIdentifierStart(int codePoint)
确定是否允许将指定字符（Unicode 代码点）作为 Unicode 标识符中的首字符。

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

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

isUnicodeIdentifierPart

public static boolean isUnicodeIdentifierPart(char ch)
确定指定字符是否可以是 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(int codePoint)
确定指定字符（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(char ch)
确定是否应该认为指定字符是 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(int codePoint)
确定是否应该认为指定字符（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(char ch)
使用来自 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(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 大小写映射方法却不能。

注：此方法无法处理增补字符。若要支持所有 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 文件的大小写映射信息将字符参数转换为首字母大写。如果字符没有明确的首字母大写映射，并且根据 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(int codePoint)
使用来自 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(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。

注：此方法无法处理增补字符。若要支持所有 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。在这种情况下，返回 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(char ch)
返回指定的 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(int codePoint)
返回指定字符（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(char ch)
已过时。 用 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(char ch)
确定指定字符是否为 Unicode 空白字符。当且仅当根据 Unicode 标准将字符指定为空白字符时，才认为字符是一个空白字符。如果字符的常规类别的类型为以下类型中的任意一种，则该方法返回 true：
  • SPACE_SEPARATOR
  • LINE_SEPARATOR
  • PARAGRAPH_SEPARATOR

注：此方法无法处理增补字符。若要支持所有 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_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(int codePoint)
确定指定字符（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(char ch)
确定指定字符是否为 ISO 控制字符。如果字符的代码在从 '\u0000' 到 '\u001F' 或从 '\u007F' 到 '\u009F' 的范围内，则认为该字符是一个 ISO 控制字符。

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

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

isISOControl

public static boolean isISOControl(int codePoint)
确定引用的字符（Unicode 代码点）是否为 ISO 控制字符。如果字符的代码在从 '\u0000' 到 '\u001F' 或从 '\u007F' 到 '\u009F' 的范围内，则认为该字符是一个 ISO 控制字符。

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

getType

public static int getType(char ch)
返回一个指示字符的常规类别的值。

注： 此方法无法处理增补字符。若要支持所有 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(int codePoint)
返回一个指示字符的常规类别的值。

参数：
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(int digit,
                            int radix)
确定使用指定基数的特定数字的字符表示形式。如果 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(char ch)
返回给定字符的 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(int codePoint)
返回给定字符（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(char ch)
确定指定字符依据 Unicode 规范是否对称。当显示在以从右至左的方式显示的文本中时，对称字符的字形在水平方向上应该是对称的。例如，'\u0028' LEFT PARENTHESIS 在语义上被定义为是开括号。在从左至右显示的文本中，它将显示为“(”，但在以从右至左的方式显示的文本中，它显示为“)”。

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

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

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

reverseBytes

public static char reverseBytes(char ch)
返回通过反转指定 char 值中的字节顺序而获得的值。

返回：
通过反转（或者等效于交换）指定 char 值中的字节而获得的值。
从以下版本开始：
1.5
概述  软件包   类  使用  树  已过时  索引  帮助 
JavaTM 2 Platform
Standard Ed. 5.0
 上一个类   下一个类 框架    无框架    
摘要： 嵌套 | 字段 | 构造方法 | 方法 详细信息： 字段 | 构造方法 | 方法
提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

版权所有 2004 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。