JDK源码阅读之Character

Character

      Character类是基本数据类型char的包装类,该类提供了几种方法,以确定字符的类别(小写字母,数字,等等),并将字符从大写转换成小写,反之亦然。Jdk1.8中字符信息基于 Unicode 标准,版本 6.2.0。

类图

Character类图

public final class Character implements java.io.Serializable, Comparable<Character>

      通过类图和源码我们可以知道Character 是不可被继承的,并且Character 类型的实例对象是可以比较的。

成员变量

好多的成员变量呀!点开看我

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           用来以无符号二进制形式表示 <tt>char</tt> 值的位数。
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           表示基本类型 charClass 实例。
static byte UNASSIGNED           Unicode 规范中的常规类别“Cn”。
static byte UPPERCASE_LETTER           Unicode 规范中的常规类别“Lu”。

构造方法

public Character(char value) {
    this.value = value;
}

      Character类只有一个构造方法,接受char类型的数据。

valueOf

public static Character valueOf(char c) {
    if (c <= 127) { // must cache
        return CharacterCache.cache[(int)c];
    }
    return new Character(c);
}

private static class CharacterCache {
    private CharacterCache(){}

    static final Character cache[] = new Character[127 + 1];

    static {
        for (int i = 0; i < cache.length; i++)
            cache[i] = new Character((char)i);
    }
}

      静态方法valueOf接受一个char类型数据c,如果c<=127则从cache中获取字符,否则new字符。CharacterCache缓存了ASCII码为[0,127]之间的字符。

hashCode

public int hashCode() {
    return Character.hashCode(value);
}
public static int hashCode(char value) {
    return (int)value;
}

      Character的hash值即为value的ASCII码。

equals

public boolean equals(Object obj) {
    if (obj instanceof Character) {
        return value == ((Character)obj).charValue();
    }
    return false;
}

      首先判断obj是否为Character类型,再判断value是否相同。

toString

public String toString() {
    char buf[] = {value};
    return String.valueOf(buf);
}

public static String toString(char c) {
    return String.valueOf(c);
}

public static String valueOf(char data[]) {
    return new String(data);
}

      最终调用String类接收字符数组的构造方法创建字符串。

isValidCodePoint

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 范围之内的有效 Unicode 代码点值。

isBmpCodePoint

public static boolean isBmpCodePoint(int codePoint) {
    return codePoint >>> 16 == 0;
}

      在UTF-16中,前216个码位均以16位的编码单元表示,这个范围被称作基本多文种平面(BMP,Basic Multilingual Plane)。超出这个范围的码位则要归属于某个辅助平面(supplementary plane),其中的码位仅用16位就无法表示了。代码点大于 U+FFFF 的字符称为增补字符。此方法判断字符是否属于这一范围,即0x0000~0xFFFF之间。

isSupplementaryCodePoint

public static boolean isSupplementaryCodePoint(int codePoint) {
    return codePoint >= MIN_SUPPLEMENTARY_CODE_POINT
        && codePoint <  MAX_CODE_POINT + 1;
}

      确定指定字符(Unicode 代码点)是否在增补字符范围内。即判断codePoint >= 0x10000 && codePoint <= 0x10FFFF

charCount

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

      确定表示指定字符(Unicode 代码点)所需的 char 值的数量。如果指定字符等于或大于0x010000,则该方法返回的值为 2。否则,该方法返回的值为 1。该方法没有验证指定的字符是否为一个有效的 Unicode 代码点。如有必要,调用者必须使用 isValidCodePoint 验证字符值。

isLetter

public static boolean isLetter(char ch) {
    return isLetter((int)ch);
}

public static boolean isLetter(int codePoint) {
    return ((((1 << Character.UPPERCASE_LETTER) |
        (1 << Character.LOWERCASE_LETTER) |
        (1 << Character.TITLECASE_LETTER) |
        (1 << Character.MODIFIER_LETTER) |
        (1 << Character.OTHER_LETTER)) >> getType(codePoint)) & 1)
        != 0;
}

      判断指定字符是否为字母。如果通过 Character.getType(ch) 为字符提供的常规类别的类型为以下类型中的任意一种,则认为该字符为字母:

  • UPPERCASE_LETTER
  • LOWERCASE_LETTER
  • TITLECASE_LETTER
  • MODIFIER_LETTER
  • OTHER_LETTER

isLetterOrDigit

public static boolean isLetterOrDigit(char ch) {
    return isLetterOrDigit((int)ch);
}
public static boolean isLetterOrDigit(int codePoint) {
    return ((((1 << Character.UPPERCASE_LETTER) |
        (1 << Character.LOWERCASE_LETTER) |
        (1 << Character.TITLECASE_LETTER) |
        (1 << Character.MODIFIER_LETTER) |
        (1 << Character.OTHER_LETTER) |
        (1 << Character.DECIMAL_DIGIT_NUMBER)) >> getType(codePoint)) & 1)
        != 0;
}

      判断指定字符是否为字母或数字。

digit

public static int digit(char ch, int radix) {
    return digit((int)ch, radix);
}
public static int digit(int codePoint, int radix) {
    return CharacterData.of(codePoint).digit(codePoint, 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。

isDigit

public static boolean isDigit(char ch) {
    return isDigit((int)ch);
}
public static boolean isDigit(int codePoint) {
    return getType(codePoint) == Character.DECIMAL_DIGIT_NUMBER;
}

      判断指定字符是否为数字。如果通过 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',全形数字

      这还是我第一次知道那么多种数字呀~~没文化了。。。

toLowerCase

public static char toLowerCase(char ch) {
    return (char)toLowerCase((int)ch);
}
public static int toLowerCase(int codePoint) {
    return CharacterData.of(codePoint).toLowerCase(codePoint);
}

      使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为小写。注意,对于某些范围内的字符,特别是那些是符号或表意符号的字符,Character.isLowerCase(Character.toLowerCase(ch)) 并不总是返回 true。
      通常,应该使用 String.toLowerCase() 将字符映射为小写。String 大小写映射方法有几个胜过 Character 大小写映射方法的优点。String 大小写映射方法可以执行语言环境敏感的映射、上下文相关的映射和 1:M 字符映射,而 Character 大小写映射方法却不能。
      注:此方法无法处理增补字符。若要支持所有 Unicode 字符,包括增补字符,请使用 toLowerCase(int) 方法。

isSpaceChar

public static boolean isSpaceChar(char ch) {
    return isSpaceChar((int)ch);
}
public static boolean isSpaceChar(int codePoint) {
    return ((((1 << Character.SPACE_SEPARATOR) |
              (1 << Character.LINE_SEPARATOR) |
              (1 << Character.PARAGRAPH_SEPARATOR)) >> getType(codePoint)) & 1)
        != 0;
}

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

  • SPACE_SEPARATOR
  • LINE_SEPARATOR
  • PARAGRAPH_SEPARATOR

isWhitespace

      判断指定字符(Unicode 代码点)依据 Java 标准是否为空白字符。当且仅当字符满足以下标准时,该字符才是一个 Java 空白字符:

  • 它是一个 Unicode 空白字符(SPACE_SEPARATOR、LINE_SEPARATOR 或
    PARAGRAPH_SEPARATOR),但不是一个不间断空格('u00A0'、'u2007' 和 'u202F')。
  • 'u0009',水平制表符't'。
  • 'u000A',换行'n'。
  • 'u000B',纵向制表符。
  • 'u000C',换页'f'。
  • 'u000D',回车'r'。
  • 'u001C',文件分隔符。
  • 'u001D',组分隔符。
  • 'u001E',记录分隔符。
  • 'u001F',单元分隔符。

      isWhitespace表示的空白范围比isSpaceChar更广啊。

compareTo

public int compareTo(Character anotherCharacter) {
    return compare(this.value, anotherCharacter.value);
}
public static int compare(char x, char y) {
    return x - y;
}

      如果前者等于后者,则返回 0;如果前者的数值小于参数 Character,则返回小于 0 的值;如果前者的数值大于参数 Character,则返回大于 0 的值(有符号比较)。注意,这是一次严格的数字比较;它并不依赖于区域。

Last modification:September 19th, 2019 at 10:51 am
如果觉得我的文章对你有用,请随意赞赏

Leave a Comment