深入学习java源码之Character.isUpperCase()与Character.isTitleCase()

深入学习java源码之Character.isUpperCase()与Character.isTitleCase()

16进制

16进制数排列依次是 0 1 2 3 4 5 6 7 8 9 A B C D E F
以10进制来看 F大小就是 15。

0xFF 是16进制数，大小就是 F * 16 + F，就是等于255

 

Modifier and Type	Method and Description
static int	charCount(int codePoint) 确定代表指定字符（Unicode代码点）所需的 char值。
char	charValue() 返回此 Character对象的值。
static int	compare(char x, char y) 数值比较两个 char数值。
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 String	getName(int codePoint) 返回指定字符的Unicode名称 codePoint ，或者如果代码点是空 unassigned 。
static int	getNumericValue(char ch) 返回指定的Unicode字符代表的 int值。
static int	getNumericValue(int codePoint) 返回 int值指定字符（Unicode代码点）表示。
static int	getType(char ch) 返回一个值，表示一个字符的一般类别。
static int	getType(int codePoint) 返回一个值，表示一个字符的一般类别。
int	hashCode() 返回这个Character的哈希码; 等于调用charValue()的结果。
static int	hashCode(char value) 返回一个char值的哈希码; 兼容Character.hashCode() 。
static char	highSurrogate(int codePoint) 返回主导替代（一个 high surrogate code unit所述的） surrogate pair表示在UTF-16编码指定的补充的字符（Unicode代码点）。
static boolean	isAlphabetic(int codePoint) 确定指定的字符（Unicode代码点）是否是字母表。
static boolean	isBmpCodePoint(int codePoint) 确定指定的字符（Unicode代码点）是否在 Basic Multilingual Plane (BMP)中 。
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值是否为 Unicode high-surrogate code unit （也称为 引导代理单元 ）。
static boolean	isIdentifierIgnorable(char ch) 确定指定的字符是否应被视为Java标识符或Unicode标识符中的可忽略字符。
static boolean	isIdentifierIgnorable(int codePoint) 确定指定字符（Unicode代码点）是否应被视为Java标识符或Unicode标识符中的可忽略字符。
static boolean	isIdeographic(int codePoint) 确定指定字符（Unicode代码点）是否是Unicode标准定义的CJKV（中文，日文，韩文和越南文）表意文字。
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值是否为 Unicode low-surrogate code unit （也称为 尾随代理单元 ）。
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代码点）是否在 supplementary character范围内。
static boolean	isSurrogate(char ch) 确定给定的 char值是否是Unicode 代理代码单元 。
static boolean	isSurrogatePair(char high, char low) 确定指定的一对 char值是否有效 Unicode surrogate pair 。
static boolean	isTitleCase(char ch) 确定指定的字符是否是一个titlecase字符。
static boolean	isTitleCase(int codePoint) 确定指定的字符（Unicode代码点）是否是一个titlecase字符。
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) 确定指定的代码点是否有效 Unicode code point value 。
static boolean	isWhitespace(char ch) 根据Java确定指定的字符是否为空格。
static boolean	isWhitespace(int codePoint) 根据Java确定指定字符（Unicode代码点）是否为空格。
static char	lowSurrogate(int codePoint) 返回尾随替代（一个 low surrogate code unit所述的） surrogate pair表示在UTF-16编码指定的补充的字符（Unicode代码点）。
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) 返回给定的char序列中与 index （ codePointOffset代码点偏移的索引。
static char	reverseBytes(char ch) 返回通过反转指定的 char值中的字节顺序获得的值。
static int	toCodePoint(char high, char low) 将指定的代理对转换为其补充代码点值。
static char	toLowerCase(char ch) 使用UnicodeData文件中的大小写映射信息将字符参数转换为小写。
static int	toLowerCase(int codePoint) 使用UnicodeData文件中的大小写映射信息将字符（Unicode代码点）参数转换为小写。
String	toString() 返回 String表示此对象 Character的价值。
static String	toString(char c) 返回一个 String对象，表示指定的 char 。
static char	toTitleCase(char ch) 使用UnicodeData文件中的案例映射信息将字符参数转换为titlecase。
static int	toTitleCase(int codePoint) 使用UnicodeData文件中的案例映射信息将字符（Unicode代码点）参数转换为titlecase。
static char	toUpperCase(char ch) 使用UnicodeData文件中的案例映射信息将字符参数转换为大写。
static int	toUpperCase(int codePoint) 使用UnicodeData文件中的案例映射信息将字符（Unicode代码点）参数转换为大写。
static Character	valueOf(char c) 返回一个 表示指定的 char值的 Character实例。

java源码

package java.lang;

import java.util.Arrays;
import java.util.Map;
import java.util.HashMap;
import java.util.Locale;


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

    public static final int MIN_RADIX = 2;

    public static final int MAX_RADIX = 36;
	
    public static final char MIN_VALUE = '\u0000';	
	
    public static final char MAX_VALUE = '\uFFFF';
	
    @SuppressWarnings("unchecked")
    public static final Class<Character> TYPE = (Class<Character>) Class.getPrimitiveClass("char");

    public static final byte UNASSIGNED = 0;

    public static final byte UPPERCASE_LETTER = 1;	

    public static final byte LOWERCASE_LETTER = 2;
	
	......
	
    public static final byte DECIMAL_DIGIT_NUMBER = 9;
	
    static final int ERROR = 0xFFFFFFFF;
	
    public static final byte DIRECTIONALITY_UNDEFINED = -1;	
	
    public static final char MIN_HIGH_SURROGATE = '\uD800';
	
    public static final char MIN_LOW_SURROGATE  = '\uDC00';
	
    public static final char MIN_SURROGATE = MIN_HIGH_SURROGATE;
	
    public static final char MAX_SURROGATE = MAX_LOW_SURROGATE;
	
    public static final int MIN_SUPPLEMENTARY_CODE_POINT = 0x010000;

    private final char value;

    private static final long serialVersionUID = 3786198910865385080L;
	
    public Character(char value) {
        this.value = value;
    }

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

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

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

    public boolean equals(Object obj) {
        if (obj instanceof Character) {
            return value == ((Character)obj).charValue();
        }
        return false;
    }
	
    public String toString() {
        char buf[] = {value};
        return String.valueOf(buf);
    }

    public static String toString(char c) {
        return String.valueOf(c);
    }
	
    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);
    }	
	
    public static int getType(char ch) {
        return getType((int)ch);
    }

    public static int getType(int codePoint) {
        return CharacterData.of(codePoint).getType(codePoint);
    }
	
    public static int compare(char x, char y) {
        return x - y;
    }	
	
    public int compareTo(Character anotherCharacter) {
        return compare(this.value, anotherCharacter.value);
    }	
	
    public static boolean isBmpCodePoint(int codePoint) {
        return codePoint >>> 16 == 0;
        // Optimized form of:
        //     codePoint >= MIN_VALUE && codePoint <= MAX_VALUE
        // We consistently use logical shift (>>>) to facilitate
        // additional runtime optimizations.
    }	
	
    public static boolean isSupplementaryCodePoint(int codePoint) {
        return codePoint >= MIN_SUPPLEMENTARY_CODE_POINT
            && codePoint <  MAX_CODE_POINT + 1;
    }
	
    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 boolean isLowSurrogate(char ch) {
        return ch >= MIN_LOW_SURROGATE && ch < (MAX_LOW_SURROGATE + 1);
    }
	
    public static boolean isSurrogate(char ch) {
        return ch >= MIN_SURROGATE && ch < (MAX_SURROGATE + 1);
    }

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

    public static boolean isLowerCase(char ch) {
        return isLowerCase((int)ch);
    }	
	
    public static boolean isLowerCase(int codePoint) {
        return getType(codePoint) == Character.LOWERCASE_LETTER ||
               CharacterData.of(codePoint).isOtherLowercase(codePoint);
    }
	
    public static boolean isUpperCase(char ch) {
        return isUpperCase((int)ch);
    }
	
    public static boolean isUpperCase(int codePoint) {
        return getType(codePoint) == Character.UPPERCASE_LETTER ||
               CharacterData.of(codePoint).isOtherUppercase(codePoint);
    }

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

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

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

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

    public static boolean isDefined(int codePoint) {
        return getType(codePoint) != Character.UNASSIGNED;
    }	
	
    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;
    }

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

    @Deprecated
    public static boolean isJavaLetter(char ch) {
        return isJavaIdentifierStart(ch);
    }

    @Deprecated
    public static boolean isJavaLetterOrDigit(char ch) {
        return isJavaIdentifierPart(ch);
    }	
	
    public static boolean isAlphabetic(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.LETTER_NUMBER)) >> getType(codePoint)) & 1) != 0) ||
            CharacterData.of(codePoint).isOtherAlphabetic(codePoint);
    }
	
    public static boolean isIdeographic(int codePoint) {
        return CharacterData.of(codePoint).isIdeographic(codePoint);
    }

    public static boolean isJavaIdentifierStart(char ch) {
        return isJavaIdentifierStart((int)ch);
    }
	
    public static char reverseBytes(char ch) {
        return (char) (((ch & 0xFF00) >> 8) | (ch << 8));
    }
	
    public static final int BYTES = SIZE / Byte.SIZE;	
	
    public static final int SIZE = 16;	
	
    public static String getName(int codePoint) {
        if (!isValidCodePoint(codePoint)) {
            throw new IllegalArgumentException();
        }
        String name = CharacterName.get(codePoint);
        if (name != null)
            return name;
        if (getType(codePoint) == UNASSIGNED)
            return null;
        UnicodeBlock block = UnicodeBlock.of(codePoint);
        if (block != null)
            return block.toString().replace('_', ' ') + " "
                   + Integer.toHexString(codePoint).toUpperCase(Locale.ENGLISH);
        // should never come here
        return Integer.toHexString(codePoint).toUpperCase(Locale.ENGLISH);
    }
	
}