java Character类源码分析

一、使用

构建Character对象：

public class CharTest {
    public static void main(String[] args) {
        Character c1 = new Character('A');
        Character c2 = Character.valueOf('a');
        System.out.println(c1); // A
        System.out.println(c2); // a
    }
}

构造函数源码：

@Deprecated(since="9")
    public Character(char value) {
        this.value = value;
    }

可见，构造函数的形式不建议使用了。

另一种方式 Character.valueOf()，其源码：

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

valueOf()方法使用了注解 @HotSpotIntrinsicCandidate，在jvm层面会有比较高效的实现。字符的十进制值小于等于127的话，将返回CharacterCache.cache[(int)c]，返回事先缓存的内容。

CharacterCache是个内部类，初始化CharacterCache的时候会缓存十进制0-127这128个字符（Character对象）。

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);
        }
    }

二、其他方法：

1、public char charValue() 返回此 Character 对象的值。

　 源码：

 @HotSpotIntrinsicCandidate
    public char charValue() {
        return value;
    }

　使用：

　System.out.println(c1.charValue());　// A

2、public int hashCode() 返回此 Character 的哈希码。

　源码：

@Override
    public int hashCode() {
        return Character.hashCode(value);
    }

    public static int hashCode(char value) {
        // char 转为 int
        return (int)value;
    }

　　使用：

　　System.out.println(c1.hashCode()); // 65

3、public String toString() 返回表示此 Character 值的 String 对象。结果是一个长度为 1 的字符串，其唯一组件是此 Character 对象表示的基本 char 值。

　源码：

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

　使用：

　System.out.println(c1.toString()); // A

4、public static String toString(char c) 返回一个表示指定 char 值的 String 对象。结果是长度为 1 的字符串，仅由指定的 char 组成。

　　源码：　　

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

    使用：

　System.out.println(Character.toString('A')); // A

5、public static boolean isValidCodePoint(int codePoint)

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

　　源码：

public static final int MIN_CODE_POINT = 0x000000;  
public static final int MAX_CODE_POINT = 0X10FFFF;
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);
    }

　　

有效的Unicode代码点的范围是['\U+0000','\U+10FFFF']，即[0x000000,0x10FFFF]，即[0000000, 10000 11111111 11111111]，即[0, 1114111]

(MAX_CODE_POINT + 1) >>> 16, 即 0b00000000 00010001 00000000 00000000 >>> 16，等于00000000 00010001

如果codePoint大于MAX_CODE_POINT，则 (codePoint>>>16) 大于00000000 00010000。故大于MAX_CODE_POINT的值是无效的Unicode代码点

如果codePoint小于0，即codePoint为十进制负数，则
-1
原码：10000000 00000000 00000000 00000001
反码：11111111 11111111 11111111 11111110
补码：11111111 11111111 11111111 11111111
-1 >>> 16 即 11111111 11111111 11111111 11111111 >>> 16，等于11111111 11111111

-2147483648（带符号int类型最小值）
原码：10000000 00000000 00000000 00000000
反码：11111111 11111111 11111111 11111111
补码：10000000 00000000 00000000 00000000
-2147483648 >>> 16 即 10000000 00000000 00000000 00000000 >>> 16，等于 10000000 00000000

因为>>>是无符号右移动，所以如果负数（int类型），其保存值的为该负数的补码，最高位（第16位）为符号位1，
无符号右移16位之后，得到高16位，大于00000000 00010001。故十进制负数是无效的Unicode 代码点。

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

　　使用：　

　　System.out.println(Character.isValidCodePoint(79)); // true
　　System.out.println(Character.isValidCodePoint(-79)); // false

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

　　源码：

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

Unicode增补字符范围：0x010000至0x10FFFF

　　使用：

　　System.out.println(Character.isSupplementaryCodePoint(65536)); // true
　　System.out.println(Character.isSupplementaryCodePoint(65535)); // false

7、

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

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

源码：

public static final char MIN_HIGH_SURROGATE = '\uD800';
public static final char MAX_HIGH_SURROGATE = '\uDBFF';
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);
}

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

高代理项范围['\uD800', '\uDBFF']；
低代理项范围['\uDC00', '\uDFFF']。

8、public static boolean isSurrogatePair(char high, char low) 确定指定的 char 值对是否为有效的代理项对。该方法等效于以下表达式：

源码：

public static boolean isSurrogatePair(char high, char low) {
    return isHighSurrogate(high) && isLowSurrogate(low);
}

9、

public static int charCount(int codePoint)

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

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

源码：

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

　　只判断是否大于0x010000。

10、public static int toCodePoint(char high,char low) 将指定的代理项对转换为其增补代码点值。该方法没有验证指定的代理项对。如有必要，调用者必须使用 isSurrogatePair 验证它。

源码：

public static final int MIN_SUPPLEMENTARY_CODE_POINT = 0x010000;
public static final char MIN_LOW_SURROGATE  = '\uDC00';
public static final char MAX_HIGH_SURROGATE = '\uDBFF';
   
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);
}

优化细节：
(high - MIN_HIGH_SURROGATE) << 10 ==> (high << 10) - (MIN_HIGH_SURROGATE << 10)

待续......................