java.lang.*中Character 源代码详解

逃离我推掉我的手 2022-12-09 11:53 253阅读 0赞

### java.lang.\*中Character 源代码详解 ###

*   *  核心方法
     *  public Character(char value)
     *  Character valueOf(char c)
     *  int hashCode(char value)
     *  boolean equals(Object obj)
     *  String toString()
     *  boolean isValidCodePoint(int codePoint)
     *  boolean isBmpCodePoint(int codePoint)
     *  boolean isSupplementaryCodePoint(int codePoint)
     *  boolean isHighSurrogate(char ch)
     *  boolean isLowSurrogate(char ch)
     *  int toChars(int codePoint, char\[\] dst, int dstIndex)
     *  char\[\] toChars(int codePoint)
     *  boolean isLowerCase(char ch)
     *  boolean isUpperCase(char ch)
     *  boolean isDigit(char ch)
     *  boolean isLetter(char ch)
     *  char toLowerCase(char ch)
     *  char toUpperCase(char ch)
     *  boolean isSpaceChar(char ch)
     *  boolean isWhitespace(char ch)
     *  int compare(char x, char y)
     *  int getType(int codePoint)

> 学习Java的同学注意了！！！  
> 学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：543120397 我们一起学Java！

## 核心方法 ##

public final
    class Character implements java.io.Serializable, Comparable<Character> { 
    
    public Character(char value) 构造函数
    Character valueOf(char c) 获取Character对象
    int hashCode(char value) 获取char的hashCode值
    boolean equals(Object obj) 比较两个对象是否相等
    String toString() 获取Character对象的字符串形式
    boolean isValidCodePoint(int codePoint) 确定指定的代码点是否有效
    boolean isBmpCodePoint(int codePoint) 确定指定的字符（Unicode代码点）是否在 Basic Multilingual Plane (BMP)中
    boolean isSupplementaryCodePoint(int codePoint) 确定指定字符（Unicode代码点）是否在 supplementary character范围内
    boolean isHighSurrogate(char ch) 确定给定的char值是否为Unicode high-surrogate code unit （也称为引导代理单元 ）
    boolean isLowSurrogate(char ch) 确定给定的char值是否为Unicode low-surrogate code unit （也称为后置代理单元 ）
    int toChars(int codePoint, char[] dst, int dstIndex) 将指定dst字符数组指定位置dstIndex的值换为codePoint
    char[] toChars(int codePoint) 将ASCII码int值转为字符
    boolean isLowerCase(char ch) 判断是否是小写字母
    boolean isUpperCase(char ch) 判断是否是大写字母
    boolean isDigit(char ch) 判断字符是否为数字
    boolean isDefined(char ch) 判断字符是否为Unicode字符
    boolean isLetter(char ch) 判断指定字符是否为字母
    char toLowerCase(char ch) 将字符转为小写字母
    char toUpperCase(char ch) 将字符转为大写字母
    boolean isSpaceChar(char ch) 判断是否为一个Unicode空格字符
    boolean isWhitespace(char ch) 判断指定字符是否为空白字符，空白符包含：空格、tab 键、换行符
    int compare(char x, char y) 比较两个字符是否相等,相等则返回0
    int getType(int codePoint) 返回一个字符的一般类别

## public Character(char value) ##

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

## Character valueOf(char c) ##

/** * 获取Character对象 */
    public static Character valueOf(char c) { 
    	//如果c的ASCII值小于等于127,都从缓存中获取
        if (c <= 127) {  // must cache
            return CharacterCache.cache[(int)c];
        }
        //否则重新new构建Character对象
        return new Character(c);
    }

## int hashCode(char value) ##

/** * 获取char的hashCode值 */
    public static int hashCode(char value) { 
    	//直接将value字符强转成int值
        return (int)value;
    }

## boolean equals(Object obj) ##

/** * 比较两个对象是否相等 */
    public boolean equals(Object obj) { 
    	//首先判断obj的类型是否为Character
        if (obj instanceof Character) { 
        	//强转obj为Character类型,并比较两者的值
            return value == ((Character)obj).charValue();
        }
        return false;
    }

## String toString() ##

/** * 获取Character对象的字符串形式 */ 
    public String toString() { 
    	//先将char转为char[]数组
        char buf[] = { value};
        //调用String.valueOf方法
        return String.valueOf(buf);
    }
    
    public static String toString(char c) { 
    	//直接调用String.valueOf方法
        return String.valueOf(c);
    }

## boolean isValidCodePoint(int codePoint) ##

/** * 确定指定的代码点是否有效 * [MIN_CODE_POINT, MAX_CODE_POINT] */
    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);
    }

## boolean isBmpCodePoint(int codePoint) ##

/** * 确定指定的字符（Unicode代码点）是否在 Basic Multilingual Plane (BMP)中 */
    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.
    }

## boolean isSupplementaryCodePoint(int codePoint) ##

/** * 确定指定字符（Unicode代码点）是否在 supplementary character范围内。 */
    public static boolean isSupplementaryCodePoint(int codePoint) { 
        return codePoint >= MIN_SUPPLEMENTARY_CODE_POINT
            && codePoint <  MAX_CODE_POINT + 1;
    }

## boolean isHighSurrogate(char ch) ##

/** * 确定给定的char值是否为Unicode high-surrogate code unit （也称为引导代理单元 ） */
    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);
    }

## boolean isLowSurrogate(char ch) ##

/** * 确定给定的char值是否为Unicode low-surrogate code unit （也称为后置代理单元 ） */
    public static boolean isLowSurrogate(char ch) { 
        return ch >= MIN_LOW_SURROGATE && ch < (MAX_LOW_SURROGATE + 1);
    }

## int toChars(int codePoint, char\[\] dst, int dstIndex) ##

/** * 将指定dst字符数组指定位置dstIndex的值换为codePoint * @param codePoint * @param dst * @param dstIndex */
    public static int toChars(int codePoint, char[] dst, int dstIndex) { 
        if (isBmpCodePoint(codePoint)) { //判断如果是BMP字符
            dst[dstIndex] = (char) codePoint;//设置索引位置的值
            return 1;
        } else if (isValidCodePoint(codePoint)) { 
            toSurrogates(codePoint, dst, dstIndex);
            return 2;
        } else { 
            throw new IllegalArgumentException();
        }
    }

## char\[\] toChars(int codePoint) ##

/** * 将ASCII码int值转为字符 * 97 -> {'a'} */
    public static char[] toChars(int codePoint) { 
        if (isBmpCodePoint(codePoint)) { 
        	//将ASCII值强制转为char[]
            return new char[] {  (char) codePoint };
        } else if (isValidCodePoint(codePoint)) { 
            char[] result = new char[2];
            toSurrogates(codePoint, result, 0);
            return result;
        } else { 
            throw new IllegalArgumentException();
        }
    }

## boolean isLowerCase(char ch) ##

/** * 判断是否是小写字母 * a-z * 如果是返回true,否则返回false */
    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);
    }

## boolean isUpperCase(char ch) ##

/** * 判断字符是否是大写字母 * A-Z */
    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);
    }

## boolean isDigit(char ch) ##

/** * 判断字符是否为数字 */
    public static boolean isDigit(char ch) { 
        return isDigit((int)ch);
    }
    
    public static boolean isDigit(int codePoint) { 
        return getType(codePoint) == Character.DECIMAL_DIGIT_NUMBER;
    }

## boolean isLetter(char ch) ##

/** * 判断指定字符是否为字母 */
    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;
    }

## char toLowerCase(char ch) ##

/** * 将字符转为小写字母 * 如果满足条件则转为小写字母 * 如果不是字母，则返回原字符 */
    public static char toLowerCase(char ch) { 
        return (char)toLowerCase((int)ch);
    }
    
    public static int toLowerCase(int codePoint) { 
       	return CharacterData.of(codePoint).toLowerCase(codePoint);
    }

## char toUpperCase(char ch) ##

/** * 将字符转为大写字母 */
    public static char toUpperCase(char ch) { 
        return (char)toUpperCase((int)ch);
    }
    
    public static int toUpperCase(int codePoint) { 
        return CharacterData.of(codePoint).toUpperCase(codePoint);
    }

## boolean isSpaceChar(char ch) ##

/** * 判断是否为一个Unicode空格字符 */
    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;
    }

## boolean isWhitespace(char ch) ##

/** * 判断指定字符是否为空白字符，空白符包含：空格、tab 键、换行符 */
    public static boolean isWhitespace(char ch) { 
        return isWhitespace((int)ch);
    }
    
    public static boolean isWhitespace(int codePoint) { 
        return CharacterData.of(codePoint).isWhitespace(codePoint);
    }

## int compare(char x, char y) ##

/** * 比较两个字符是否相等,相等则返回0 */
    public static int compare(char x, char y) { 
        return x - y;
    }

## int getType(int codePoint) ##

/** * 返回一个字符的一般类别 * LOWERCASE_LETTER = 2 代表小写字母类型 * UPPERCASE_LETTER = 1 代表大写字母类型 * DECIMAL_DIGIT_NUMBER = 9 代表数字类型 */
    public static int getType(int codePoint) { 
        return CharacterData.of(codePoint).getType(codePoint);
    }