JDK1.8源码学习--lang包(Character)

最新推荐文章于 2023-02-07 16:04:49 发布

月央泽

最新推荐文章于 2023-02-07 16:04:49 发布

阅读量559

点赞数

文章标签： java intellij idea jdk1.8

本文链接：https://blog.csdn.net/w5_Silence/article/details/121532571

版权

前言

月是一轮明镜,晶莹剔透,代表着一张白纸(啥也不懂)

央是一片海洋,海乃百川,代表着一块海绵(吸纳万物)

泽是一柄利剑,千锤百炼,代表着千百锤炼(输入输出)

月央泽,学习的一种过程,从白纸->吸收各种知识->不断输入输出变成自己的内容

希望大家一起坚持这个过程,也同样希望大家最终都能从零到零,把知识从薄变厚,再由厚变薄!

一.Character的作用:

直接看源码注释(我的翻译可能不太准,如果道友们有更棒的理解,可以留言或者私信)

/**
 * The {@code Character} class wraps a value of the primitive
 * type {@code char} in an object. An object of type
 * {@code Character} contains a single field whose type is
 * {@code char}.
 * 1.Character是原始类型char的包装类,内部维护了一个char类型的字段
 * <p>
 * In addition, this class provides several methods for determining
 * a character's category (lowercase letter, digit, etc.) and for converting
 * characters from uppercase to lowercase and vice versa.
 * 2.该类提供了一些方法,来确定char的类型(小写字母,数字等),以及在大小写之间相互转化
 * <p>
 * Character information is based on the Unicode Standard, version 6.2.0.
 * 3.字符信息是基于Unicode标准
 * <p>
 * The methods and data of class {@code Character} are defined by
 * the information in the <i>UnicodeData</i> file that is part of the
 * Unicode Character Database maintained by the Unicode
 * Consortium. This file specifies various properties including name
 * and general category for every defined Unicode code point or
 * character range.
 * 3.Character类中方法和数据是有UnicodeData文件中的信息定义,改文件是Unicode Consortium维护的
 * Unicode字符数据库的一部分,该文件为每个定义的Unicode代码点或字符范围指定了各种属性,包括名称和一般类别
 * <p>
 * The file and its description are available from the Unicode Consortium at:
 * <ul>
 * <li><a href="http://www.unicode.org">http://www.unicode.org</a>
 * </ul>
 *
 * <h3><a name="unicode">Unicode Character Representations</a></h3>
 *
 * <p>The {@code char} data type (and therefore the value that a
 * {@code Character} object encapsulates) are based on the
 * original Unicode specification, which defined characters as
 * fixed-width 16-bit entities. The Unicode Standard has since been
 * changed to allow for characters whose representation requires more
 * than 16 bits.  The range of legal <em>code point</em>s is now
 * U+0000 to U+10FFFF, known as <em>Unicode scalar value</em>.
 * (Refer to the <a
 * href="http://www.unicode.org/reports/tr27/#notation"><i>
 * definition</i></a> of the U+<i>n</i> notation in the Unicode
 * Standard.)
 *  4.char数据类型和Character包装类,是基于原始的Unicode规范,该规范character为16个字节,
 *  该Unicode标准已经更改为允许表示超过16位字符,现在核发的代码点的范围是U+0000到U+10FFFF
 *
 * <p><a name="BMP">The set of characters from U+0000 to U+FFFF</a> is
 * sometimes referred to as the <em>Basic Multilingual Plane (BMP)</em>.
 * <a name="supplementary">Characters</a> whose code points are greater
 * than U+FFFF are called <em>supplementary character</em>s.  The Java
 * platform uses the UTF-16 representation in {@code char} arrays and
 * in the {@code String} and {@code StringBuffer} classes. In
 * this representation, supplementary characters are represented as a pair
 * of {@code char} values, the first from the <em>high-surrogates</em>
 * range, (&#92;uD800-&#92;uDBFF), the second from the
 * <em>low-surrogates</em> range (&#92;uDC00-&#92;uDFFF).
 * 5.U+0000到U+10FFFF 的char有时被称为基本多文种平面(BMP),Character中超过U+FFFF的字符被称为补充字符
 * 6.Java平台在char数组和String,StringBuffer类中使用UTF-16来表示,在这种表示中,补充字符表示一对char值,
 * 第一个来自高代理范围,第二个来自低代理范围
 *
 * <p>A {@code char} value, therefore, represents Basic
 * Multilingual Plane (BMP) code points, including the surrogate
 * code points, or code units of the UTF-16 encoding. An
 * {@code int} value represents all Unicode code points,
 * including supplementary code points. The lower (least significant)
 * 21 bits of {@code int} are used to represent Unicode code
 * points and the upper (most significant) 11 bits must be zero.
 * Unless otherwise specified, the behavior with respect to
 * supplementary characters and surrogate {@code char} values is
 * as follows:
 * 7.一个char值,代表着基本多文种平面代码点.包括代理代码点或者UTF-16编码的代码单位
 * (一个int值,代表所有的代码点,包括补充代码点)
 * 8.int值的低21位是用于表示Unicode代码点,高11位必须为零
 *
 * <ul>
 * <li>The methods that only accept a {@code char} value cannot support
 * supplementary characters. They treat {@code char} values from the
 * surrogate ranges as undefined characters. For example,
 * {@code Character.isLetter('\u005CuD840')} returns {@code false}, even though
 * this specific value if followed by any low-surrogate value in a string
 * would represent a letter.
 * 9.char值不能支持补充字符,他们将代理范围称为未定义字符
 *
 * <li>The methods that accept an {@code int} value support all
 * Unicode characters, including supplementary characters. For
 * example, {@code Character.isLetter(0x2F81A)} returns
 * {@code true} because the code point value represents a letter
 * (a CJK ideograph).
 * </ul>
 *  10.int值支持所有的编码字符,包括补充字符
 * <p>In the Java SE API documentation, <em>Unicode code point</em> is
 * used for character values in the range between U+0000 and U+10FFFF,
 * and <em>Unicode code unit</em> is used for 16-bit
 * {@code char} values that are code units of the <em>UTF-16</em>
 * encoding. For more information on Unicode terminology, refer to the
 * <a href="http://www.unicode.org/glossary/">Unicode Glossary</a>.
 * 11.在JavaSE API文档中,Unicode代码点字符的使用范围是U+0000 and U+10FFFF,Unicode代码但愿是用于作为UTF-16代码单元的16位
 * @author  Lee Boynton
 * @author  Guy Steele
 * @author  Akira Tanaka
 * @author  Martin Buchholz
 * @author  Ulf Zibis
 * @since   1.0
 */

二.Character的类图:

a).一个Comparable,这个接口对实现他的每个对象都可按照一定的规则来进行排序,详情请点击下面链接

JDK1.8源码学习--lang包(Comparable)_w5_Silence的博客-CSDN博客

b).Secializable,这个接口是可为实现的对象进行序列化,详情请点击下面链接
......(假装这个是链接,以后补充)

三.成员变量:

   /**
     *  可用于与字符串相互转化的最小基数(进制数)
     */
    public static final int MIN_RADIX = 2;

    /**
     *  可用于与字符串相互转换的最大基数(进制数)
     */
    public static final int MAX_RADIX = 36;

    /**
     * 该字段是char类型的最小值
     */
    public static final char MIN_VALUE = '\u0000';

    /**
     *  该字段是char类型的最大值
     */
    public static final char MAX_VALUE = '\uFFFF';

    /**
     *  原始类型char的Class对象
     */
    @SuppressWarnings("unchecked")
    public static final Class<Character> TYPE = (Class<Character>) Class.getPrimitiveClass("char");

下面是一些Unicode中的一般规范,了解即可:


    public static final byte UNASSIGNED = 0;

    public static final byte UPPERCASE_LETTER = 1;

    public static final byte LOWERCASE_LETTER = 2;

    public static final byte TITLECASE_LETTER = 3;

    public static final byte MODIFIER_LETTER = 4;

    public static final byte OTHER_LETTER = 5;

    public static final byte NON_SPACING_MARK = 6;

    public static final byte ENCLOSING_MARK = 7;

    public static final byte COMBINING_SPACING_MARK = 8;

    public static final byte DECIMAL_DIGIT_NUMBER        = 9;

    public static final byte LETTER_NUMBER = 10;

    public static final byte OTHER_NUMBER = 11;

    public static final byte SPACE_SEPARATOR = 12;

    public static final byte LINE_SEPARATOR = 13;

    public static final byte PARAGRAPH_SEPARATOR = 14;

    public static final byte CONTROL = 15;

    public static final byte FORMAT = 16;

    public static final byte PRIVATE_USE = 18;

    public static final byte SURROGATE = 19;

    public static final byte DASH_PUNCTUATION = 20;

    public static final byte START_PUNCTUATION = 21;

    public static final byte END_PUNCTUATION = 22;

    public static final byte CONNECTOR_PUNCTUATION = 23;

    public static final byte OTHER_PUNCTUATION = 24;

    public static final byte MATH_SYMBOL = 25;

    public static final byte CURRENCY_SYMBOL = 26;

    public static final byte MODIFIER_SYMBOL = 27;

    public static final byte OTHER_SYMBOL = 28;

    public static final byte INITIAL_QUOTE_PUNCTUATION = 29;

    public static final byte FINAL_QUOTE_PUNCTUATION = 30;

下面是一些Unicode规范中强双向字符,了解即可:

    public static final byte DIRECTIONALITY_UNDEFINED = -1;

    public static final byte DIRECTIONALITY_LEFT_TO_RIGHT = 0;

    public static final byte DIRECTIONALITY_RIGHT_TO_LEFT = 1;

    public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC = 2;

    public static final byte DIRECTIONALITY_EUROPEAN_NUMBER = 3;

    public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR = 4;

    public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR = 5;

    public static final byte DIRECTIONALITY_ARABIC_NUMBER = 6;

    public static final byte DIRECTIONALITY_COMMON_NUMBER_SEPARATOR = 7;

    public static final byte DIRECTIONALITY_NONSPACING_MARK = 8;

    public static final byte DIRECTIONALITY_BOUNDARY_NEUTRAL = 9;

    public static final byte DIRECTIONALITY_PARAGRAPH_SEPARATOR = 10;

    public static final byte DIRECTIONALITY_SEGMENT_SEPARATOR = 11;

    public static final byte DIRECTIONALITY_WHITESPACE = 12;

    public static final byte DIRECTIONALITY_OTHER_NEUTRALS = 13;

    public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING = 14;

    public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE = 15;

    public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING = 16;

    public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE = 17;

    public static final byte DIRECTIONALITY_POP_DIRECTIONAL_FORMAT = 18;

其他成员变量:

     /**
     * 错误标记,使用int的代码点,避免和U+FFFF混淆
     */
    static final int ERROR = 0xFFFFFFFF;

    /**
     *  最小的高代理
     */
    public static final char MIN_HIGH_SURROGATE = '\uD800';

    /**
     *  最大的高代理
     */
    public static final char MAX_HIGH_SURROGATE = '\uDBFF';

    /**
     *  最小的低代理
     */
    public static final char MIN_LOW_SURROGATE  = '\uDC00';

    /**
     *  最大的高代理
     */
    public static final char MAX_LOW_SURROGATE  = '\uDFFF';

    /**
     *  将最小的高代理赋值给字段MIN_SURROGATE
     */
    public static final char MIN_SURROGATE = MIN_HIGH_SURROGATE;

    /**
     *  将最大的低代理赋值给字段MAX_SURROGATE
     */
    public static final char MAX_SURROGATE = MAX_LOW_SURROGATE;

    /**
     *  最小的补充代码点
     */
    public static final int MIN_SUPPLEMENTARY_CODE_POINT = 0x010000;

    /**
     *  最小的代码点
     */
    public static final int MIN_CODE_POINT = 0x000000;

    /**
     *  最大的代码点
     */
    public static final int MAX_CODE_POINT = 0X10FFFF;

      /**
     *  用以无符号的二进制表示的char的位数
     */
    public static final int SIZE = 16;

    /**
     *  用于以无符号二进制形式表示的char的字节数
     */
    public static final int BYTES = SIZE / Byte.SIZE;

四.内部类:

Subset

    /**
     * 1.此类的实例表示Unicode字符集的特定子集
     * 2.Character类中定义的唯一子集是Character.UnicodeBlock,
     * java API的其他部分可能会为它们自己的目的定义其他子集
     */
    public static class Subset  {

        //子集的名称
        private String name;

        /**
         *  创建一个新的实例,如果name为null会抛出NullPointerException
         */
        protected Subset(String name) {
            if (name == null) {
                throw new NullPointerException("name");
            }
            this.name = name;
        }

        /**
         * 比较两个子集是否相等
         */
        public final boolean equals(Object obj) {
            return (this == obj);
        }

        /**
         * 返回标准的Object方法中的哈希值,
         * 此方法是为了保证所有的子类中的此方法保持一致
         */
        public final int hashCode() {
            return super.hashCode();
        }

        /**
         * 返回此子集的名字
         */
        public final String toString() {
            return name;
        }
    }

UnicodeBlock和UnicodeScript是Character内部维护的编码块和编码脚本,内容较多,有兴趣的小伙伴可以自行前面源码查看,这里小编就不在上源码了.

CharacterCache

    //内部维护了一个Character的缓存数组
    private static class CharacterCache {
        private CharacterCache(){}
        //长度为128的Character数组
        static final Character cache[] = new Character[127 + 1];

        static {
            for (int i = 0; i < cache.length; i++)
                //值是从0-127
                cache[i] = new Character((char)i);
        }
    }

五.构造方法:

  /**
     *  创建一个新分配的Character对象,表示指定的char值
     */
    public Character(char value) {
        this.value = value;
    }

六.内部方法:

valueOf(char c)

     /**
     * 1.返回一个char值为c的Character对象.
     * 2.如果并不要求是一个新的对象,那么这个方法优先于构造方法使用,因为他会有更明显的空间和时间效率
     * 3.调用这个方法时只有当char值小于等于127才会使用CharacterCache的缓存数组
     */
    public static Character valueOf(char c) {
        if (c <= 127) { // must cache
            return CharacterCache.cache[(int)c];
        }
        return new Character(c);
    }

charValue

    /**
     *返回当前对象的char值
     */
    public char charValue() {
        return value;
    }

hashCode

  /**
     * 放回当前对象的哈希值(直接强转为int),
     */
    @Override
    public int hashCode() {
        return Character.hashCode(value);
    }

    /**
     *放回当前对象的哈希值(直接强转为int),
     */
    public static int hashCode(char value) {
        return (int)value;
    }

equals(Object obj)

      /**
     *1.将此对象与指定对象比较
     * 2.仅当此对象是Character类型,同时起char值相等返回true,其他返回false

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

toString()

   /**
     *  将Character值转为String
     */
    public String toString() {
        //把Character的value值fangruchar数组,调用String.valueOf()
        char buf[] = {value};
        return String.valueOf(buf);
    }

    /**
     *  将指定的char值转为String
     */
    public static String toString(char c) {
        return String.valueOf(c);
    }

判断代码点的一系列方法:

     /**
     *  确定指定的代码点是一个有效的Unicode代码点值
     */
    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代码点)是否在基本多文种平面中
     *  此类代码点可以使用单个的char值来表示
     */
    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.
    }

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

    /**
     *  将特殊的代理对转化为补充代码点值,该方法不会验证这对char值是否是代理对,如有需要,直接调用
     *  isSurrogatePair验证
     */
    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);
    }

 /**
     *  1.返回CharSequence值中给定索引位置的代码点
     *  2.如果CharSequence中给定索引的char值处于高代理范围内,则后面的索引小于CharSequence
     *  的长度,并且后面索引的char值处于第代理范围内,则返回与该代理对对应的补充代码点.
     *  否则,返回给定索引出的char值
     */
    public static int codePointAt(CharSequence seq, int index) {
        char c1 = seq.charAt(index);
        if (isHighSurrogate(c1) && ++index < seq.length()) {
            char c2 = seq.charAt(index);
            if (isLowSurrogate(c2)) {
                return toCodePoint(c1, c2);
            }
        }
        return c1;
    }

    /**
     *  1.返回指定char数组索引下的代码点
     *  2.如果CharSequence中给定索引的char值处于高代理范围内,则后面的索引小于CharSequence
     * 的长度,并且后面索引的char值处于第代理范围内,则返回与该代理对对应的补充代码点.
     * 否则,返回给定索引出的char值
     */
    public static int codePointAt(char[] a, int index) {
        return codePointAtImpl(a, index, a.length);
    }

    /**
     *  1.返回指定char数组索引下的代码点,其中只能使用索引小于limit的元素
     *  2.如果CharSequence中给定索引的char值处于高代理范围内,则后面的索引小于CharSequence
     *的长度,并且后面索引的char值处于第代理范围内,则返回与该代理对对应的补充代码点.
     * 否则,返回给定索引出的char值
     */
    public static int codePointAt(char[] a, int index, int limit) {
        if (index >= limit || limit < 0 || limit > a.length) {
            throw new IndexOutOfBoundsException();
        }
        return codePointAtImpl(a, index, limit);
    }

    // throws ArrayIndexOutOfBoundsException if index out of bounds
    static int codePointAtImpl(char[] a, int index, int limit) {
        char c1 = a[index];
        if (isHighSurrogate(c1) && ++index < limit) {
            char c2 = a[index];
            if (isLowSurrogate(c2)) {
                return toCodePoint(c1, c2);
            }
        }
        return c1;
    }

    /**
     * 1.返回CharSequence值中给定索引位置前一个的代码点
     * 2.如果CharSequence中给定索引前一个的char值处于高代理范围内,则后面的索引小于CharSequence
     * 的长度,并且后面索引的char值处于第代理范围内,则返回与该代理对对应的补充代码点.
     * 否则,返回给定索引前一个出的char值
     */
    public static int codePointBefore(CharSequence seq, int index) {
        char c2 = seq.charAt(--index);
        if (isLowSurrogate(c2) && index > 0) {
            char c1 = seq.charAt(--index);
            if (isHighSurrogate(c1)) {
                return toCodePoint(c1, c2);
            }
        }
        return c2;
    }

    /**
     *  1.返回指定char数组索引前一个下的代码点
     *  2.如果CharSequence中给定索引前一个的char值处于高代理范围内,则后面的索引小于CharSequence
     * 的长度,并且后面索引的char值处于第代理范围内,则返回与该代理对对应的补充代码点.
     * 否则,返回给定索引前一个出的char值
     */
    public static int codePointBefore(char[] a, int index) {
        return codePointBeforeImpl(a, index, 0);
    }

    /**
     *  1.返回指定char数组索引前一个下的代码点,索引start开始
     *  2.如果CharSequence中给定索引前一个的char值处于高代理范围内,则后面的索引小于CharSequence
     * 的长度,并且后面索引的char值处于第代理范围内,则返回与该代理对对应的补充代码点.
     * 否则,返回给定索引前一个出的char值
     */
    public static int codePointBefore(char[] a, int index, int start) {
        if (index <= start || start < 0 || start >= a.length) {
            throw new IndexOutOfBoundsException();
        }
        return codePointBeforeImpl(a, index, start);
    }

    // throws ArrayIndexOutOfBoundsException if index-1 out of bounds
    static int codePointBeforeImpl(char[] a, int index, int start) {
        char c2 = a[--index];
        if (isLowSurrogate(c2) && index > start) {
            char c1 = a[--index];
            if (isHighSurrogate(c1)) {
                return toCodePoint(c1, c2);
            }
        }
        return c2;
    }

  /**
     *1.返回指定字符序列的文本范围内的 Unicode 代码点数。
     * 2.文本范围从指定的 beginIndex开始，并扩展到索引endIndex - 1处的  char。
     * 3.因此文本范围的长度是endIndex-beginIndex。
     * 4.文本范围内未配对的代理每个都算作一个代码点
     */
    public static int codePointCount(CharSequence seq, int beginIndex, int endIndex) {
        int length = seq.length();
        if (beginIndex < 0 || endIndex > length || beginIndex > endIndex) {
            throw new IndexOutOfBoundsException();
        }
        int n = endIndex - beginIndex;
        for (int i = beginIndex; i < endIndex; ) {
            if (isHighSurrogate(seq.charAt(i++)) && i < endIndex &&
                isLowSurrogate(seq.charAt(i))) {
                n--;
                i++;
            }
        }
        return n;
    }

    /**
     *1.返回 {@code char} 数组参数的子数组中的 Unicode 代码点数。 
     * 2.offset 参数是子数组char的索引，count 参数指定子数组的长度。
     * 3.子阵列中未配对的代理每个都算作一个代码点
     */
    public static int codePointCount(char[] a, int offset, int count) {
        if (count > a.length - offset || offset < 0 || count < 0) {
            throw new IndexOutOfBoundsException();
        }
        return codePointCountImpl(a, offset, count);
    }

    static int codePointCountImpl(char[] a, int offset, int count) {
        int endIndex = offset + count;
        int n = count;
        for (int i = offset; i < endIndex; ) {
            if (isHighSurrogate(a[i++]) && i < endIndex &&
                isLowSurrogate(a[i])) {
                n--;
                i++;
            }
        }
        return n;
    }

  /**
     *1.返回给定字符序列中的索引，该索引从给定的 index偏移 codePointOffset代码点。 
     * 2.index和 codePointOffset给出的文本范围内的未配对代理每个都算作一个代码点
     */
    public static int offsetByCodePoints(CharSequence seq, int index,
                                         int codePointOffset) {
        int length = seq.length();
        if (index < 0 || index > length) {
            throw new IndexOutOfBoundsException();
        }

        int x = index;
        if (codePointOffset >= 0) {
            int i;
            for (i = 0; x < length && i < codePointOffset; i++) {
                if (isHighSurrogate(seq.charAt(x++)) && x < length &&
                    isLowSurrogate(seq.charAt(x))) {
                    x++;
                }
            }
            if (i < codePointOffset) {
                throw new IndexOutOfBoundsException();
            }
        } else {
            int i;
            for (i = codePointOffset; x > 0 && i < 0; i++) {
                if (isLowSurrogate(seq.charAt(--x)) && x > 0 &&
                    isHighSurrogate(seq.charAt(x-1))) {
                    x--;
                }
            }
            if (i < 0) {
                throw new IndexOutOfBoundsException();
            }
        }
        return x;
    }

    /**
     * 1.返回给定 子数组中的索引，该索引从给定的 index偏移  codePointOffset代码点。 
     * 2.start和 count参数指定 数组的子数组。 
     * 3.index和 codePointOffset给出的文本范围内的未配对代理每个都算作一个代码点
     */
    public static int offsetByCodePoints(char[] a, int start, int count,
                                         int index, int codePointOffset) {
        if (count > a.length-start || start < 0 || count < 0
            || index < start || index > start+count) {
            throw new IndexOutOfBoundsException();
        }
        return offsetByCodePointsImpl(a, start, count, index, codePointOffset);
    }

    static int offsetByCodePointsImpl(char[]a, int start, int count,
                                      int index, int codePointOffset) {
        int x = index;
        if (codePointOffset >= 0) {
            int limit = start + count;
            int i;
            for (i = 0; x < limit && i < codePointOffset; i++) {
                if (isHighSurrogate(a[x++]) && x < limit &&
                    isLowSurrogate(a[x])) {
                    x++;
                }
            }
            if (i < codePointOffset) {
                throw new IndexOutOfBoundsException();
            }
        } else {
            int i;
            for (i = codePointOffset; x > start && i < 0; i++) {
                if (isLowSurrogate(a[--x]) && x > start &&
                    isHighSurrogate(a[x-1])) {
                    x--;
                }
            }
            if (i < 0) {
                throw new IndexOutOfBoundsException();
            }
        }
        return x;
    }

判断代理的一系列方法:

 /**
     *  1.确定指定的char值是都为高代理代码单元
     *  2.这些值本身并不是代表字符,而是用于UTF-16编码中的补充字符表示
     */
    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);
    }

    /**
     *  1.确定指定的char值是都为低代理代码单元
     *  2.这些值本身并不是代表字符,而是用于UTF-16编码中的补充字符表示
     */
    public static boolean isLowSurrogate(char ch) {
        return ch >= MIN_LOW_SURROGATE && ch < (MAX_LOW_SURROGATE + 1);
    }

    /**
     *1.确定指定的char值是都为代理代码单元
     *2.这些值本身并不是代表字符,而是用于UTF-16编码中的补充字符表示
     */
    public static boolean isSurrogate(char ch) {
        return ch >= MIN_SURROGATE && ch < (MAX_SURROGATE + 1);
    }

    /**

        确定指定的char值对是否是有效的Unicode代理对
     */
    public static boolean isSurrogatePair(char high, char low) {
        return isHighSurrogate(high) && isLowSurrogate(low);
    }

  /**
     *  1.返回代理对的前导代理(高代理代码单元)(UTF-16编码中指定的补充字符).
     *  如果指定的字符不是补充字符,则返回未指定的char
     */
    public static char highSurrogate(int codePoint) {
        return (char) ((codePoint >>> 10)
            + (MIN_HIGH_SURROGATE - (MIN_SUPPLEMENTARY_CODE_POINT >>> 10)));
    }

    /**
     *   1.返回代理对的尾随代理(低代理代码单元)(UTF-16编码中指定的补充字符).
     *  如果指定的字符不是补充字符,则返回未指定的char
     */
    public static char lowSurrogate(int codePoint) {
        return (char) ((codePoint & 0x3ff) + MIN_LOW_SURROGATE);
    }

charCount(int codePoint)

     /**
     *  1.确定指定字符(Unicode代码点)所需要的char值数量,如果指定字符等于或大于0x10000,
     *  则方法返回2,否则该方法返回1
 
     * 2.此方法不会将指定的字符验证为有效的Unicode代码点,如果有必要,
     * 调用者必须使用isValidCodePoint验证
     *
     */
    public static int charCount(int codePoint) {
        return codePoint >= MIN_SUPPLEMENTARY_CODE_POINT ? 2 : 1;
    }

将指定的字符(代码点)转化为其UTF-16表示

   /**
     *  1.将指定的字符(Unicode代码点)转化其UTF-16表示.如果指定的代码点是BMP值,
     *  则相同的值存储在指定的char数组中指定的索引位置,并返回1
     *  2.如果指定代码点是增补字符,则其代理值存在索引值位置的char数组内()高代理和索引位置+1的char数组位置(低代理),
     *  并返回2
     */
    public static int toChars(int codePoint, char[] dst, int dstIndex) {
        if (isBmpCodePoint(codePoint)) {
            dst[dstIndex] = (char) codePoint;
            return 1;
        } else if (isValidCodePoint(codePoint)) {
            toSurrogates(codePoint, dst, dstIndex);
            return 2;
        } else {
            throw new IllegalArgumentException();
        }
    }

    /**
     *  1.将指定的字符（Unicode 代码点）转换为其存储在 char 数组中的 UTF-16 表示。
     *  如果指定的代码点是 BMP（基本多语言平面或平面 0）值，
     *  则生成的 char 数组与 codePoint 具有相同的值。
     *  2.如果指定的代码点是补充代码点，则生成的  char数组具有相应的代理对
     */
    public static char[] toChars(int codePoint) {
        if (isBmpCodePoint(codePoint)) {
            return new char[] { (char) codePoint };
        } else if (isValidCodePoint(codePoint)) {
            char[] result = new char[2];
            toSurrogates(codePoint, result, 0);
            return result;
        } else {
            throw new IllegalArgumentException();
        }
    }

    static void toSurrogates(int codePoint, char[] dst, int index) {
        // We write elements "backwards" to guarantee all-or-nothing
        dst[index+1] = lowSurrogate(codePoint);
        dst[index] = highSurrogate(codePoint);
    }

其中还有一些判断字符为什么类型的,种类很多,有兴趣的可以去亲自看看(我反正是涨知识了)

将字符转为大写或小写或标题类型:

  /**

     * 1使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为小写

     * 2.请注意此方法并不总是为某些范围的字符返回 true，尤其是那些符号或表意文字
   
     * 3.通常，应该使用StringtoLowerCase()将字符映射到小写。
     * String大小写映射方法比 Character 大小写映射方法有几个优点:
     * String大小写映射方法可以执行区域设置敏感映射、上下文敏感映射和 1:M 字符映射，
     * 而 Character大小写映射方法不能

     */
    public static char toLowerCase(char ch) {
        return (char)toLowerCase((int)ch);
    }

    /**

     *使用来自 UnicodeData 文件的大小写映射信息将字符（Unicode 代码点）参数转换为小写
     */
    public static int toLowerCase(int codePoint) {
        return CharacterData.of(codePoint).toLowerCase(codePoint);
    }

    /**
     * 使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为大写
     */
    public static char toUpperCase(char ch) {
        return (char)toUpperCase((int)ch);
    }

    /**

     * 使用来自 UnicodeData 文件的大小写映射信息将字符（Unicode 代码点）参数转换为大写
     */
    public static int toUpperCase(int codePoint) {
        return CharacterData.of(codePoint).toUpperCase(codePoint);
    }

    /**
     * 使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为 titlecase。
     * 如果一个字符没有明确的 titlecase 映射，并且根据 UnicodeData 本身不是 titlecase 字符，
     * 那么大写映射将作为等效的 titlecase 映射返回。如果 char参数已经是 titlecase ，
     * 则将返回相同的 char 值
     */
    public static char toTitleCase(char ch) {
        return (char)toTitleCase((int)ch);
    }

    /**
     * 使用来自 UnicodeData 文件的大小写映射信息将字符（Unicode 代码点）参数转换为 titlecase。
     * 如果一个字符没有明确的 titlecase 映射，并且根据 UnicodeData 本身不是 titlecase 字符，
     * 那么大写映射将作为等效的 titlecase 映射返回。如果字符参数已经是 titlecase 字符，
     * 则将返回相同的字符值

     */
    public static int toTitleCase(int codePoint) {
        return CharacterData.of(codePoint).toTitleCase(codePoint);
    }

digit()

  /**

     * 返回指定基数中字符ch的数值
    
     * 如果基数不在 MIN_RADIX≤ radix ≤ MAX_RADIX范围内，
     * ch的值不是指定基数中的有效数字，则-1  返回
   
     */
    public static int digit(char ch, int radix) {
        return digit((int)ch, radix);
    }

    /**
     *返回指定基数中指定字符（Unicode 代码点）的数值。
     */
    public static int digit(int codePoint, int radix) {
        return CharacterData.of(codePoint).digit(codePoint, radix);
    }

getNumericValue

 /**
     * 返回指定的 Unicode 字符表示的 int值。
     * 例如，字符 '\u005Cu216C'（罗马数字五十）将返回一个值为 50 的 int
   
     */
    public static int getNumericValue(char ch) {
        return getNumericValue((int)ch);
    }

    /**
     * 返回指定字符（Unicode 代码点）表示的 int 值。
     * 例如，字符 '\u005Cu216C'（罗马数字 50）将返回值为 50 的  int
     */
    public static int getNumericValue(int codePoint) {
        return CharacterData.of(codePoint).getNumericValue(codePoint);
    }

判断空格:



    /**

     *1.确定指定的字符是否为 Unicode 空格字符。当且仅当 Unicode 标准将字符指定为空格字符时，才认为该字符是空格字符
   
     * 2.此方法无法处理补充字符,要支持所有 Unicode 字符，包括增补字符，请使用 isSpaceChar(int) 方法

     */
    public static boolean isSpaceChar(char ch) {
        return isSpaceChar((int)ch);
    }

    /**
     *1.确定指定的字符（Unicode 代码点）是否为 Unicode 空格字符。当且仅当 Unicode 标准将字符指定为空格字符时，才认为该字符是空格字符。
     */
    public static boolean isSpaceChar(int codePoint) {
        return ((((1 << Character.SPACE_SEPARATOR) |
                  (1 << Character.LINE_SEPARATOR) |
                  (1 << Character.PARAGRAPH_SEPARATOR)) >> getType(codePoint)) & 1)
            != 0;
    }

    /**
     *1.根据Java判断指定字符是否为空格
     *2.此方法无法处理补充字符。要支持所有 Unicode 字符，包括增补字符，请使用 isWhitespace(int) 方法
     */
    public static boolean isWhitespace(char ch) {
        return isWhitespace((int)ch);
    }

    /**
     *根据 Java 确定指定的字符（Unicode 代码点）是否为空格
     */
    public static boolean isWhitespace(int codePoint) {
        return CharacterData.of(codePoint).isWhitespace(codePoint);
    }

isISOControl

 /**
     * 1.确定指定的字符是否为 ISO 控制字符。
     * 如果一个字符的代码在  '\u005Cu0000' 到 '\u005Cu001F'范围内或在  '\u005Cu007F' 到 范围内，
     * 则该字符被认为是 ISO 控制字符'\u005Cu009F'
     */
    public static boolean isISOControl(char ch) {
        return isISOControl((int)ch);
    }

    /**
     * 1.确定指定的字符是否为 ISO 控制字符。
     *      * 如果一个字符的代码在  '\u005Cu0000' 到 '\u005Cu001F'范围内或在  '\u005Cu007F' 到 范围内，
     *      * 则该字符被认为是 ISO 控制字符'\u005Cu009F'

     */
    public static boolean isISOControl(int codePoint) {
        // Optimized form of:
        //     (codePoint >= 0x00 && codePoint <= 0x1F) ||
        //     (codePoint >= 0x7F && codePoint <= 0x9F);
        return codePoint <= 0x9F &&
            (codePoint >= 0x7F || (codePoint >>> 5 == 0));
    }

getType

  /**
     * Returns a value indicating a character's general category.
     *1.返回一个值，指示字符的一般类别
     *2.此方法无法处理补充字符。
     * 要支持所有 Unicode 字符，包括增补字符，请使用 {@link getType(int)} 方法
     */
    public static int getType(char ch) {
        return getType((int)ch);
    }

    /**
     * Returns a value indicating a character's general category.
     *返回一个值，指示字符的一般类别。
     */
    public static int getType(int codePoint) {
        return CharacterData.of(codePoint).getType(codePoint);
    }

forDigit

   /**
     * 1.确定指定基数中特定数字的字符表示。
     * 如果 radix的值不是有效基数，或者 digit的值不是指定基数中的有效数字，则返回空字符 '\u005Cu0000'
     */
    public static char forDigit(int digit, int radix) {
        if ((digit >= radix) || (digit < 0)) {
            return '\0';
        }
        if ((radix < Character.MIN_RADIX) || (radix > Character.MAX_RADIX)) {
            return '\0';
        }
        //小于10
        if (digit < 10) {
            
            return (char)('0' + digit);
        }
        //大于10
        return (char)('a' - 10 + digit);
    }

getDirectionlity(char ch)

  /**
     *1.返回给定字符的 Unicode 方向性属性。
     * 字符方向性用于计算文本的视觉顺序。未定义的  char值的方向性值为  DIRECTIONALITY_UNDEFINED
     *2.此方法无法处理补充字符。
     * 要支持所有 Unicode 字符，包括增补字符，请使用 getDirectionality(int)方法
     */
    public static byte getDirectionality(char ch) {
        return getDirectionality((int)ch);
    }

    /**
     *返回给定字符（Unicode 代码点）的 Unicode 方向性属性。字符方向性用于计算文本的视觉顺序
     */
    public static byte getDirectionality(int codePoint) {
        return CharacterData.of(codePoint).getDirectionality(codePoint);
    }

isMirrored

 /**
     * 确定字符是否根据 Unicode 规范进行镜像。
     * 当以从右到左的文本显示时，镜像字符的字形应该水平镜像。
     * 例如，'\u005Cu0028' LEFT PARENTHESIS 在语义上定义为 左括号。
     * 这将在从左到右的文本中显示为“（”，但在从右到左的文本中显示为“）
 
     此方法无法处理补充字符
     要支持所有 Unicode 字符，包括增补字符，请使用 isMirrored(int) 方法     *
     */
    public static boolean isMirrored(char ch) {
        return isMirrored((int)ch);
    }

    /**
     * 确定指定的字符（Unicode 代码点）是否根据 Unicode 规范进行镜像。
     * 当以从右到左的文本显示时，镜像字符的字形应该水平镜像。
     * 例如，'\u005Cu0028' LEFT PARENTHESIS 在语义上定义为 左括号。
     * 这将在从左到右的文本中显示为“（”，但在从右到左的文本中显示为“）”
     */
    public static boolean isMirrored(int codePoint) {
        return CharacterData.of(codePoint).isMirrored(codePoint);
    }

compare()

 /**
     *以数字方式比较两个 Character 对象
     */
    public int compareTo(Character anotherCharacter) {
        return compare(this.value, anotherCharacter.value);
    }

    /**
     * 以数字方式比较两个  char 值。
     */
    public static int compare(char x, char y) {
        return x - y;
    }

toUpperCaseEx

   /**
     * 使用来自 UnicodeData 文件的信息将字符（Unicode 代码点）参数转换为大写
     */
    static int toUpperCaseEx(int codePoint) {
        assert isValidCodePoint(codePoint);
        return CharacterData.of(codePoint).toUpperCaseEx(codePoint);
    }

    /**

     * 使用来自 Unicode 规范中的 SpecialCasing 文件的大小写映射信息将字符（Unicode 代码点）参数转换为大写。
     * 如果字符没有显式大写映射，则 char 本身在  char[]中返回
     */
    static char[] toUpperCaseCharArray(int codePoint) {
        // As of Unicode 6.0, 1:M uppercasings only happen in the BMP.
        assert isBmpCodePoint(codePoint);
        return CharacterData.of(codePoint).toUpperCaseCharArray(codePoint);
    }

reverseBytes

 /**
     * 返回通过反转指定char值中的字节顺序获得的值
     */
    public static char reverseBytes(char ch) {
        return (char) (((ch & 0xFF00) >> 8) | (ch << 8));
    }

getName()

   /**
     * 1.返回指定字符  codePoint 的 Unicode 名称，
     * 如果代码点为 UNASSIGNED unassigned，则返回 null
     *2.如果UnicodeData文件（Unicode Consortium维护的Unicode字符数据库的一部分）
     * 没有为指定的字符指定名称，则返回的名称与表达式的结果相同
     */
    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);
    }

七.总结:

字节果然很底层,出现了很多不理解的概念和知识点.

果然知道的越多,不知道的越多.继续加油!

月央泽

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JDK1.8源码学习--lang包(Character)

前言月是一轮明镜,晶莹剔透,代表着一张白纸(啥也不懂)央是一片海洋,海乃百川,代表着一块海绵(吸纳万物)泽是一柄利剑,千锤百炼,代表着千百锤炼(输入输出)月央泽,学习的一种过程,从白纸->吸收各种知识->不断输入输出变成自己的内容希望大家一起坚持这个过程,也同样希望大家最终都能从零到零,把知识从薄变厚,再由厚变薄!一.Character的作用: 直接看源码注释(我的翻译可能不太准,如果道友们有更棒的理解,可以留言或者私信)/** * The ...
复制链接

扫一扫