Java-API简析_java.lang.Character类（基于 Latest JDK）（浅析源码）

【版权声明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权）
https://blog.csdn.net/m0_69908381/article/details/131178778
出自【进步*于辰的博客】

推荐博文阅读（转发）

1. 字符串编码(ASCII, GBK, ANSI, Unicode(‘\u‘), UTF-8编码)；
2. Java中的字符集编码入门－增补字符；

1、概述

继承关系：

• java.lang.Object
  • java.lang.Character

所有已实现的接口：
Serializable、Comparable<Character>

---

public final class Character extends Object implements Serializable, Comparable<Character>

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

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

字符信息基于 $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 表示法的定义）。（注：有些资料中表明其中有2048个码位非法）

从 U+0000 到 U+FFFF （共 2¹⁶ 个码位）的字符集有时也称为$基本多语言面$（Basic Multilingual Plane，BMP)，代码点大于 U+FFFF 的字符称为$增补字符$。Java 2 平台在 char 数组以及 String 和 StringBuffer 类中使用 UTF-16 表示形式。在这种表现形式中，增补字符表示为一对 char 值，第一个值取自$高代理项$范围，即\uD800 - \uDBFF（共1024个码位），第二个值取自$低代理项$范围，即\uDC00 - \uDFFF（共1024个码点）。 综上所述，Unicode码空间一共有：

1024 * 1024 + 65536 - 2048 = 1,112,064

个码点，但其中很多码位是空闲的。以 Unicode 4.0 规范为例，只有96,382个码位被分配了字符。

所以，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》。

$说明：$（摘录自第二篇推荐博文）

• 代码点 （Code Point）是指 Unicode 中为字符分配的编号，一个字符只占一个代码点，如：字符“汉”，代码点是U+6C49；

• 代码单元（Code Unit） 是针对编码方法而言，它指的是编码方法中对一个字符编码以后所占的最小存储单元。
  注：虽然代码单元是存储单元，表示用几个字节来表示字符（由编码方式决定），但并不是指1/2/3…个字节，而是指占1/2/3.。。个字节的码位。

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

2、字段摘要

2.1 static final int SIZE

以二进制补码形式表示 Character 值的位数。

public static final int SIZE = 16;// 占2个字节

2.2 static final Class<Character> TYPE

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

public static final Class<Character> TYPE = (Class<Character>) Class.getPrimitiveClass("char");

关于getPrimitiveClass()，见Class<T>类的第3.1项，即返回char.class。

2.3 static final char MAX_VALUE

保持 Character 类型的最大值的常量可取的值为 2¹⁶－1。

public static final char MAX_VALUE = '\uFFFF';

$BMP$的最大值，也可以理解为16位无符号二进制的最大值。

2.4 static final char MIN_VALUE

保持 Character 类型的最小值的常量可取的值为 0。

public static final char MIN_VALUE = '\u0000';

$BMP$的最小值，同理。

3、嵌套类摘要

3.1 static class Character.Subset

此类的实例表示 Unicode 字符集的特定子集。（暂未可知）

3.2 static class Character.UnicodeBlock

表示 Unicode 规范中字符块的一系列字符子集。（暂未可知）

4、构造方法摘要

属性说明：

private final char value;

4.1 char value

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

5、方法摘要

5.1 static int charCount(int codePoint)

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

public static int charCount(int codePoint) {
    return codePoint >= MIN_SUPPLEMENTARY_CODE_POINT ? 2 : 1;
}

大于增补字符的最小值，是增补字符，占2个字符。

示例。（以第6.1项的输出结果为例）

int cc1 = 55296;
int cc2 = 1113088;
int cc3 = 56320;
int cc4 = 57343;
System.out.println(Character.charCount(cc1));// 1
System.out.println(Character.charCount(cc2));// 2
System.out.println(Character.charCount(cc3));// 1
System.out.println(Character.charCount(cc4));// 1

5.2 char charValue()

返回此 Character 对象的值。

5.3 static int codePointAt(char[] a, int index)

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

5.4 static int codePointAt(char[] a, int index, int limit)

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

5.5 static int codePointAt(CharSequence seq, int index)

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

5.6 static int codePointBefore(char[] a, int index)

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

5.7 static int codePointBefore(char[] a, int index, int start)

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

5.8 static int codePointBefore(CharSequence seq, int index)

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

5.9 static int codePointCount(char[] a, int offset, int count)

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

5.10 static int codePointCount(CharSequence seq, int beginIndex, int endIndex)

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

5.11 static int compareTo(Character anotherCharacter)

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

5.12 static int digit(char ch, int radix)

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

public static int digit(char ch, int radix) {
    return digit((int)ch, radix);
}

调用下1项。

示例。

Character.digit('1', 2);// 1
Character.digit('1', 8);// 1
Character.digit('1', 10);// 1
Character.digit('1', 16);// 1

Character.digit('7', 2);// -1
Character.digit('7', 8);// 7
Character.digit('7', 10);// 7
Character.digit('7', 16);// 7

Character.digit('f', 2);// -1
Character.digit('f', 8);// -1
Character.digit('f', 10);// -1
Character.digit('f', 16);// 15

此处“基数”是“进制”，意思是将指定字符视为指定进制的字符，返回对应十进制。若指定字符不是指定进制的字符，返回-1。

5.13 static int digit(int codePoint, int radix)

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

public static int digit(int codePoint, int radix) {
    return CharacterData.of(codePoint).digit(codePoint, radix);
}

关于类 CharacterData，后续补充。

示例可参考上1项，后续补充解析。

5.14 boolean equals(Object obj)

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

5.15 static char forDigit(int digit, int radix)

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

5.16 static byte getDirectionality(char ch)

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

5.17 static byte getDirectionality(int codePoint)

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

5.18 static int getNumericValue(char ch)

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

5.19 static int getNumericValue(int codePoint)

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

5.20 static int getType(char ch)

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

5.21 static int getType(int codePoint)

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

5.22 int hashCode()

返回此 Character 的哈希码。

5.23 static boolean isDefined(char ch)

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

5.24 static boolean isDefined(int codePoint)

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

5.25 static boolean isDigit(char ch)

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

5.26 static boolean isDigit(int codePoint)

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

5.27 static boolean isHighSurrogate(char ch)

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

public static boolean isHighSurrogate(char ch) {
    // Help VM constant-fold; MAX_HIGH_SURROGATE + 1 == MIN_LOW_SURROGATE
    return ch >= MIN_HIGH_SURROGATE && ch < (MAX_HIGH_SURROGATE + 1);
}

5.28 static boolean isIdentifierIgnorable(char ch)

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

5.29 static boolean isIdentifierIgnorable(int codePoint)

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

5.30 static boolean isISOControl(char ch)

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

5.31 static boolean isISOControl(int codePoint)

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

5.32 static boolean isJavaIdentifierPart(char ch)

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

5.33 static boolean isJavaIdentifierPart(int codePoint)

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

5.34 static boolean isJavaIdentifierStart(char ch)

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

5.35 static boolean isJavaIdentifierStart(int codePoint)

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

5.36 static boolean isJavaLetter(char ch)

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

5.37 static boolean isJavaLetterOrDigit(char ch)

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

5.38 static boolean isLetter(char ch)

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

5.39 static boolean isLetter(int codePoint)

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

5.40 static boolean isLetterOrDigit(char ch)

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

5.41 static boolean isLetterOrDigit(int codePoint)

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

5.42 static boolean isLowerCase(char ch)

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

5.43 static boolean isLowerCase(int codePoint)

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

5.44 static boolean isLowSurrogate(char ch)

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

public static boolean isLowSurrogate(char ch) {
    return ch >= MIN_LOW_SURROGATE && ch < (MAX_LOW_SURROGATE + 1);
}

5.45 static boolean isMirrored(char ch)

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

5.46 static boolean isMirrored(int codePoint)

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

5.47 static boolean isSpace(char ch)

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

5.48 static boolean isSpaceChar(char ch)

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

5.49 static boolean isSpaceChar(int codePoint)

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

5.50 static boolean isSupplementaryCodePoint(int codePoint)

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

5.51 static boolean isSurrogatePair(char high, char low)

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

5.52 static boolean isTitleCase(char ch)

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

5.53 static boolean isTitleCase(int codePoint)

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

5.54 static boolean isUnicodeIdentifierPart(char ch)

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

5.55 static boolean isUnicodeIdentifierPart(int codePoint)

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

5.56 static boolean isUnicodeIdentifierStart(char ch)

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

5.57 static boolean isUnicodeIdentifierStart(int codePoint)

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

5.58 static boolean isUpperCase(char ch)

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

5.59 static boolean isUpperCase(int codePoint)

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

5.60 static boolean isValidCodePoint(int codePoint)

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

public static boolean isValidCodePoint(int codePoint) {
    // Optimized form of:
    //     codePoint >= MIN_CODE_POINT && codePoint <= MAX_CODE_POINT
    int plane = codePoint >>> 16;
    return plane < ((MAX_CODE_POINT + 1) >>> 16);
}

$合法代码点$的范围是0x0000到0x10ffff，故若指定代码点大于0x10ffff则是无效代码点。

$为什么要右移16位？$
因为在此范围内，也包含$增补字符$，从概述中可知，增补字符由两个 char 变量组成，char 变量由16位二进制表示。

5.61 static boolean isWhitespace(char ch)

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

5.62 static boolean isWhitespace(int codePoint)

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

5.63 static int offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset)

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

5.64 static int offsetByCodePoints(CharSequence seq, int index, int codePointOffset)

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

5.65 static char reverseBytes(char ch)

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

5.66 static char[] toChars(int codePoint)

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

5.67 static int toChars(int codePoint, char[] dst, int dstIndex)

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

5.68 static int toCodePoint(char high, char low)

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

public static int toCodePoint(char high, char low) {
    // Optimized form of:
    // return ((high - MIN_HIGH_SURROGATE) << 10)
    //         + (low - MIN_LOW_SURROGATE)
    //         + MIN_SUPPLEMENTARY_CODE_POINT;
    return ((high << 10) + low) + (MIN_SUPPLEMENTARY_CODE_POINT
                                   - (MIN_HIGH_SURROGATE << 10)
                                   - MIN_LOW_SURROGATE);
}

暂不理解其运算逻辑，后续说明。

5.69 static char toLowerCase(char ch)

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

5.70 static int toLowerCase(int codePoint)

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

5.71 String toString()

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

5.72 static String toString(char c)

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

5.73 static char toTitleCase(char ch)

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

5.74 static int toTitleCase(int codePoint)

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

5.75 static char toUpperCase(char ch)

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

5.76 static int toUpperCase(int codePoint)

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

5.77 static Chracter valueOf(char c)

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

5.78 static char highSurrogate(int codePoint)

返回指定代码点对应的搞代理项。

public static char highSurrogate(int codePoint) {
    return (char) ((codePoint >>> 10)
        + (MIN_HIGH_SURROGATE - (MIN_SUPPLEMENTARY_CODE_POINT >>> 10)));
}

暂不理解其运算逻辑，后续说明。

5.79 static char lowSurrogate(int codePoint)

返回指定代码点对应的低代理项。

public static char lowSurrogate(int codePoint) {
    return (char) ((codePoint & 0x3ff) + MIN_LOW_SURROGATE);
}

暂不理解其运算逻辑，后续说明。

6、方法摘要（不开放）

6.1 static int codePointAtImpl(char[] a, int index, int limit)

在指定字符序列中的指定限制范围内，若指定索引处的字符是高代理项，且下一个字符是低代理项，则返回此代理项对的增补代码点；否则，返回指定索引处字符的代码点。

static int codePointAtImpl(char[] a, int index, int limit) {
    char c1 = a[index];
    if (isHighSurrogate(c1) && ++index < limit) {
        char c2 = a[index];
        if (isLowSurrogate(c2)) {
            return toCodePoint(c1, c2);
        }
    }
    return c1;
}

关于isHighSurrogate()，见第5.27项；关于isLowSurrogate()，见第5.44项；关于toCodePoint()，见第5.68项。

示例。

char c1 = Character.MIN_HIGH_SURROGATE;// 55296
char c2 = Character.MAX_HIGH_SURROGATE;// 56319
char c3 = Character.MIN_LOW_SURROGATE;// 56320
char c4 = Character.MAX_LOW_SURROGATE;// 57343
char[] arr = {c1, c2, c3, c4};// c2 是增补字符

Class z1 = Character.class;
Method m1 = z1.getDeclaredMethod("codePointAtImpl", char[].class, int.class, int.class);
m1.setAccessible(true);
System.out.println(m1.invoke(null, arr, 0, arr.length));// 55296
System.out.println(m1.invoke(null, arr, 1, arr.length));// 1113088
System.out.println(m1.invoke(null, arr, 2, arr.length));// 56320
System.out.println(m1.invoke(null, arr, 3, arr.length));// 57343

6.2 static int codePointBeforeImpl(char[] a, int index, int start)

在指定字符序列中的指定限制范围内，若指定索引前一位的字符是低代理项，且上一个字符是高代理项，则返回此代理项对的增补代码点；否则，返回指定索引处字符的代码点。

static int codePointBeforeImpl(char[] a, int index, int start) {
    char c2 = a[--index];
    if (isLowSurrogate(c2) && index > start) {
        char c1 = a[--index];
        if (isHighSurrogate(c1)) {
            return toCodePoint(c1, c2);
        }
    }
    return c2;
}

关于isLowSurrogate()，见第5.44项；关于isHighSurrogate()，见第5.27项；关于toCodePoint()，见第5.68项。

示例。

char c1 = Character.MIN_HIGH_SURROGATE;// 55296
char c2 = Character.MAX_HIGH_SURROGATE;// 56319
char c3 = Character.MIN_LOW_SURROGATE;// 56320
char c4 = Character.MAX_LOW_SURROGATE;// 57343
char[] arr = {c1, c2, c3, c4};// c2 是增补字符

Class z1 = Character.class;
Method m1 = z1.getDeclaredMethod("codePointBeforeImpl", char[].class, int.class, int.class);
m1.setAccessible(true);
System.out.println(m1.invoke(null, arr, 1, -1));// 55296
System.out.println(m1.invoke(null, arr, 2, -1));// 56319
System.out.println(m1.invoke(null, arr, 3, -1));// 1113088
System.out.println(m1.invoke(null, arr, 4, -1));// 57343

6.3 static int codePointCountImpl(char[] a, int offset, int count)

返回指定字符序列中从指定开始索引开始的指定长度范围内非增补字符的个数。

static int codePointCountImpl(char[] a, int offset, int count) {
    int endIndex = offset + count;
    int n = count;
    for (int i = offset; i < endIndex; ) {
        if (isHighSurrogate(a[i++]) && i < endIndex &&
            isLowSurrogate(a[i])) {
            n--;
            i++;
        }
    }
    return n;
}

关于isHighSurrogate()，见第5.27项；关于isLowSurrogate()，见第5.44项。

示例。

char c1 = Character.MIN_HIGH_SURROGATE;// 55296
char c2 = Character.MAX_HIGH_SURROGATE;// 56319
char c3 = Character.MIN_LOW_SURROGATE;// 56320
char c4 = Character.MAX_LOW_SURROGATE;// 57343
char[] arr = {c1, c2, c3, c4};// c2 是增补字符

Class z1 = Character.class;
Method m1 = z1.getDeclaredMethod("codePointCountImpl", char[].class, int.class, int.class);
m1.setAccessible(true);
System.out.println(m1.invoke(null, arr, 0, arr.length));// 3
System.out.println(m1.invoke(null, arr, 1, arr.length - 1));// 3
System.out.println(m1.invoke(null, arr, 2, arr.length - 2));// 2
System.out.println(m1.invoke(null, arr, 3, arr.length - 3));// 1

最后

如果大家需要Java-API文档，我上传了《Java-API文档-包含5/8/11三个版本》。

---

本文暂缓更新。