深入学习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 TypeMethod and Descriptionstatic intcharCount(int codePoint)

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

charcharValue()

返回此 Character对象的值。

static intcompare(char x, char y)

数值比较两个 char数值。

intcompareTo(Character anotherCharacter)

数字比较两个 Character对象。

static intdigit(char ch, int radix)

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

static intdigit(int codePoint, int radix)

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

booleanequals(Object obj)

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

static charforDigit(int digit, int radix)

确定指定基数中特定数字的字符表示。

static bytegetDirectionality(char ch)

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

static bytegetDirectionality(int codePoint)

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

static StringgetName(int codePoint)

返回指定字符的Unicode名称 codePoint ，或者如果代码点是空 unassigned 。

static intgetNumericValue(char ch)

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

static intgetNumericValue(int codePoint)

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

static intgetType(char ch)

返回一个值，表示一个字符的一般类别。

static intgetType(int codePoint)

返回一个值，表示一个字符的一般类别。

inthashCode()

返回这个Character的哈希码; 等于调用charValue()的结果。

static inthashCode(char value)

返回一个char值的哈希码; 兼容Character.hashCode() 。

static charhighSurrogate(int codePoint)

返回主导替代（一个 high surrogate code unit所述的） surrogate pair表示在UTF-16编码指定的补充的字符（Unicode代码点）。

static booleanisAlphabetic(int codePoint)

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

static booleanisBmpCodePoint(int codePoint)

确定指定的字符（Unicode代码点）是否在 Basic Multilingual Plane (BMP)中 。

static booleanisDefined(char ch)

确定字符是否以Unicode定义。

static booleanisDefined(int codePoint)

确定Unicode中是否定义了一个字符（Unicode代码点）。

static booleanisDigit(char ch)

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

static booleanisDigit(int codePoint)

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

static booleanisHighSurrogate(char ch)

确定给定的 char值是否为 Unicode high-surrogate code unit （也称为 引导代理单元 ）。

static booleanisIdentifierIgnorable(char ch)

确定指定的字符是否应被视为Java标识符或Unicode标识符中的可忽略字符。

static booleanisIdentifierIgnorable(int codePoint)

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

static booleanisIdeographic(int codePoint)

确定指定字符（Unicode代码点）是否是Unicode标准定义的CJKV（中文，日文，韩文和越南文）表意文字。

static booleanisISOControl(char ch)

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

static booleanisISOControl(int codePoint)

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

static booleanisJavaIdentifierPart(char ch)

确定指定的字符是否可以是Java标识符的一部分，而不是第一个字符。

static booleanisJavaIdentifierPart(int codePoint)

确定字符（Unicode代码点）可能是Java标识符的一部分，而不是第一个字符。

static booleanisJavaIdentifierStart(char ch)

确定指定字符是否允许作为Java标识符中的第一个字符。

static booleanisJavaIdentifierStart(int codePoint)

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

static booleanisJavaLetter(char ch)已弃用

替换为isJavaIdentifierStart（char）。

static booleanisJavaLetterOrDigit(char ch)已弃用

由isJavaIdentifierPart（char）替代。

static booleanisLetter(char ch)

确定指定的字符是否是一个字母。

static booleanisLetter(int codePoint)

确定指定的字符（Unicode代码点）是否是一个字母。

static booleanisLetterOrDigit(char ch)

确定指定的字符是字母还是数字。

static booleanisLetterOrDigit(int codePoint)

确定指定的字符（Unicode代码点）是字母还是数字。

static booleanisLowerCase(char ch)

确定指定的字符是否是小写字符。

static booleanisLowerCase(int codePoint)

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

static booleanisLowSurrogate(char ch)

确定给定的 char值是否为 Unicode low-surrogate code unit （也称为 尾随代理单元 ）。

static booleanisMirrored(char ch)

根据Unicode规范确定字符是否镜像。

static booleanisMirrored(int codePoint)

确定是否根据Unicode规范镜像指定的字符（Unicode代码点）。

static booleanisSpace(char ch)已弃用

替换为isWhitespace（char）。

static booleanisSpaceChar(char ch)

确定指定的字符是否是Unicode空格字符。

static booleanisSpaceChar(int codePoint)

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

static booleanisSupplementaryCodePoint(int codePoint)

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

static booleanisSurrogate(char ch)

确定给定的 char值是否是Unicode 代理代码单元 。

static booleanisSurrogatePair(char high, char low)

确定指定的一对 char值是否有效 Unicode surrogate pair 。

static booleanisTitleCase(char ch)

确定指定的字符是否是一个titlecase字符。

static booleanisTitleCase(int codePoint)

确定指定的字符（Unicode代码点）是否是一个titlecase字符。

static booleanisUnicodeIdentifierPart(char ch)

确定指定的字符是否可以是Unicode标识符的一部分，而不是第一个字符。

static booleanisUnicodeIdentifierPart(int codePoint)

确定指定的字符（Unicode代码点）是否可能是Unicode标识符的一部分，而不是第一个字符。

static booleanisUnicodeIdentifierStart(char ch)

确定指定字符是否允许为Unicode标识符中的第一个字符。

static booleanisUnicodeIdentifierStart(int codePoint)

确定Unicode标识符中的第一个字符是否允许指定的字符（Unicode代码点）。

static booleanisUpperCase(char ch)

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

static booleanisUpperCase(int codePoint)

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

static booleanisValidCodePoint(int codePoint)

确定指定的代码点是否有效 Unicode code point value 。

static booleanisWhitespace(char ch)

根据Java确定指定的字符是否为空格。

static booleanisWhitespace(int codePoint)

根据Java确定指定字符（Unicode代码点）是否为空格。

static charlowSurrogate(int codePoint)

返回尾随替代（一个 low surrogate code unit所述的） surrogate pair表示在UTF-16编码指定的补充的字符（Unicode代码点）。

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

返回给定的 char子阵列中的索引，该子阵列与 index由 codePointOffset代码点偏移。

static intoffsetByCodePoints(CharSequence seq, int index, int codePointOffset)

返回给定的char序列中与 index （ codePointOffset代码点偏移的索引。

static charreverseBytes(char ch)

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

static inttoCodePoint(char high, char low)

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

static chartoLowerCase(char ch)

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

static inttoLowerCase(int codePoint)

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

StringtoString()

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

static StringtoString(char c)

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

static chartoTitleCase(char ch)

使用UnicodeData文件中的案例映射信息将字符参数转换为titlecase。

static inttoTitleCase(int codePoint)

使用UnicodeData文件中的案例映射信息将字符（Unicode代码点）参数转换为titlecase。

static chartoUpperCase(char ch)

使用UnicodeData文件中的案例映射信息将字符参数转换为大写。

static inttoUpperCase(int codePoint)

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

static CharactervalueOf(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 {

    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 TYPE = (Class) 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 = MIN_CODE_POINT && 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 >>) 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