前言
月是一轮明镜,晶莹剔透,代表着一张白纸(啥也不懂)
央是一片海洋,海乃百川,代表着一块海绵(吸纳万物)
泽是一柄利剑,千锤百炼,代表着千百锤炼(输入输出)
月央泽,学习的一种过程,从白纸->吸收各种知识->不断输入输出变成自己的内容
希望大家一起坚持这个过程,也同样希望大家最终都能从零到零,把知识从薄变厚,再由厚变薄!
一.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, (\uD800-\uDBFF), the second from the
* <em>low-surrogates</em> range (\uDC00-\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);
}七.总结:
字节果然很底层,出现了很多不理解的概念和知识点.
果然知道的越多,不知道的越多.继续加油!
215
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
