说明 若方法有多个重载,将会省略个别的代码具体实现过程,贴出该重载的声明.
目录
Object
toString() equals() hashCode() clone() getClass() finalize() notify() notifyAll() wait()
包装类
Character
Boolean
Number抽象类
继承Number的 Integer Long Short Byte
Integer 和 Long 的方法(Integer和Long两个包装类中的方法一致)
Integer部分方法详解
Object
java中所有类的主线的祖先,所有其他类都由此派生
Object方法有9个方法
toString()
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
equals()
public boolean equals(Object obj) {
return (this == obj);
}
== 检查同一性 即是否为同一个对象的引用
equals 检查相等性 ,相等性包括同一性,即 == 是equals 的一种情况
- 自反性 ∀x∉null 则 x.equals(x) 应返回true
- 对称性 ∀x,y x.equals(y)=true 时 y.equals(x) 也应返回true
- 传递性 ∀x,y,z x.equals(y)=true,y.equals(z)=true, 则 x.equals(z)应返回true
- 一致性 若x,y为发生改变则,反复调用 x.equals(y)时结果应一致
- ∀x∉null x.equals(null)应返回false
0.命名 equals(otherObject) 1.空检测 if(otherObject == null) return false; 2.检测this和otherObject是否引用同一个对象 if(this == otherObject) return true; 3.同类检测 if(getClass() != otherObject.getClass()) return false; 4.转换成同一类后进行开始对所有需要比较的域进行比较 ==比较基本类型域 equals比较对象域 ClassName other = (ClassName) otherObject; return field1 == other.field1 &&object.equals(field2,other.field2) &&...; 5.若子类要重新定义 equals 则需要包含 super.equals(other)
java.util.Arrays.equals(type[] a ,type[] b) 长度及对应位上的数据元素也均相同 将返回true
java.util.Object.equals(Object a,Object b) a b都为null时返回,只有其一为null则返回false
hashCode()
public native int hashCode();
返回一个整数 即对象的散列码 类似于一个对象的签名或校验和 由对象的内容而生成
equals返回true的两个对象的hashCode返回值必须一样
将对象存储到Hashtable(称为字典或关联数组)是会用到散列码
Object的默认实现并没有真正实现这一方案
clone()
protected native Object clone() throws CloneNotSupportedException;
为使自己是可以复制的 对象必须实现java.lang.Cloneable接口 (标志接口,表此对象希望得到复制)
若对象不可复值则抛出CloneNotSupportedException异常
1. = 使用等号赋值 只是将引用指向统一对象
2. clone() 使用clone克隆方法 得到复制 且为浅拷贝,
3.深拷贝
getClass()
public final native Class<?> getClass();
返回次Object的运行时类类型。
不可重写,要调用的话,一般和getName()联合使用,如getClass().getName();
finalize()
protected void finalize() throws Throwable { }
子类可以覆盖该方法以实现资源清理工作,GC在回收对象之前调用该方法
不同于c++中的析构函数 C++中的析构函数调用的时机是确定的(对象离开作用域或delete掉),但Java中的finalize的调用具有不确定性 ,它最主要的用途是回收特殊渠道申请的内存。比如调如非ava代码
notify()
public final native void notify();
唤醒在该对象上等待的某个线程。
notifyAll()
public final native void notifyAll();
唤醒在该对象上等待的所有线程。
wait()
public final void wait() throws InterruptedException {
wait(0);
}
//timeout 等待的最长时间毫秒 nanos - 额外时间 纳秒
public final native void wait(long timeout) throws InterruptedException;
public final void wait(long timeout, int nanos) throws InterruptedException {
if (timeout < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos > 0) {
timeout++;
}
wait(timeout);
}
1000000*timeout+nanos (纳秒) 1纳秒(ns)=1e-6毫秒(ms)
wait()会让出对象锁,同时,当前线程休眠,等待被唤醒,如果不被唤醒,就一直等在那儿。
notify()并不会让当前线程休眠,但会唤醒休眠的线程。
包装类
基本数据类型 | 对应的包装类 |
---|---|
boolean | Boolean |
char | Character |
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
基本类型 与 包装类的转换
基本类型 --> 包装类的转换 :java9将构造函数已过时 推荐使用 静态方法 :
public static 包装类 valueOf(包装类对应的基本类型)
public static 包装类 valueOf(String s)
基本类型 <-- 包装类的转换 xxxValue() 返回对应的基本类型
除Character类为 其他包装类都有 parsexxx(string)的方法 根据字符串返回基本类型值
Integer a = 12; // 自动装箱
int b = a; //自动拆箱
编译器将上面转换成
Integer a = Integer.valueOf(12);
int b = a.intValue();
都重写了Object中的 equals() hashCode() toString()
包装类都实现了Comparable接口 ,它只有一个方法 compareTo()
public interface Comparable <T>{
public int compareTo(T o); //小于 .等于 .大于 参数时 返回-1 0 1
}
包装类(除Boolean类)都定义了常量
MAX_VALUE | 该包装类对应的基本类型的最大值 |
MIN_VALUE | 该包装类对应的基本类型的最小值 |
SIZE | 该包装类对应的基本类型规定的位数 |
BYTES | 该包装类对应的基本类型规定的字节数 |
Boolean
public final class Boolean implements java.io.Serializable,
Comparable<Boolean>{
public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);
private static final long serialVersionUID = -3665804199014368530L;
public static final Class<Boolean> TYPE = (Class<Boolean>) Class.getPrimitiveClass("boolean");
private final boolean value;
//已过时的构造函数 略
/*
*返回Boolean表示指定boolean值的实例 。
*如果指定的boolean值是true,则此方法返回Boolean.TRUE; 如果是false,则此方法返回Boolean.FALSE。
*如果Boolean不需要新实例,则通常应优先使用此方法,
*而不是构造函数 Boolean(boolean),因为此方法可能会产生明显更好的空间和时间性能。
*/
public static Boolean valueOf(boolean b) {
return (b ? TRUE : FALSE);
}
/*返回Boolean带有指定字符串表示的值的a
*在Boolean返回的代表真值如果字符串参数不是null ,是平等的,
*忽略大小写,字符串"true"。否则,返回false值,包括null参数。
*/
public static Boolean valueOf(String s) {
return parseBoolean(s) ? TRUE : FALSE;
}
//将String s的值转换成 boolean
public static boolean parseBoolean(String s) {
return ((s != null) && s.equalsIgnoreCase("true"));
}
//当存在name值的系统变量存在则返回 true
public static boolean getBoolean(String name) {
boolean result = false;
try {
result = parseBoolean(System.getProperty(name));
} catch (IllegalArgumentException | NullPointerException e) {
}
return result;
}
/*
* String name = "a" ;
* System.setProperty(name, "true");
* System.out.println(Boolean.getBoolean(name));//true
* System.setProperty(name, "fasle");
* System.out.println(Boolean.getBoolean(name));//fasle
*/
}
Boolean类的方法
public static boolean | return |
logicalAnd(boolean a, boolean b) | a && b |
logicalOr(boolean a, boolean b) | a || b |
logicalXor(boolean a, boolean b) | a ^ b |
parseBoolean(String s) | 当s不为空且其值为"true"时返回true (Boolean) |
getBoolean(String name) | 当且仅当以参数命名的系统属性存在 |
修饰符 | 方法名(参数) | return语句 | 说明 |
public static int | compare(boolean x, boolean y) | (x == y) ? 0 : (x ? 1 : -1) | 两个参数 0相等 1 大于 -1小于 |
public int | compareTo(Boolean b) | compare(this.value, b.value) | 一个参数 具体实现由compareTo() |
public static String | toString(boolean b) | b ? "true" : "false" | 将Boolean zh转换成对应的string |
public static Boolean | valueOf(boolean b) | (b ? TRUE : FALSE) | |
public static Boolean | valueOf(String s) | parseBoolean(s) ? TRUE : FALSE | |
public boolean | booleanValue() | value | boolean java.lang.Boolean.value |
public int | hashCode() | value ? 1231 : 1237 | 返回此 1231代表true 1237表示false |
Number抽象类
提供了转换成 7 种数基本类型的方法
public abstract class Number implements java.io.Serializable {
public abstract int intValue();
public abstract long longValue();
public abstract float floatValue();
public abstract double doubleValue();
public byte byteValue() {
return (byte)intValue();
}
public short shortValue() {
return (short)intValue();
}
private static final long serialVersionUID = -8742448824652078965L;
public static int compare(char x, char y) {
return x - y;
}
/*序列化Serializable接口,
*序列化操作的时候系统会把当前类的serialVersionUID写入到序列化文件中
*当反序列化时系统会去检测文件中的serialVersionUID,
*判断它是否与当前类的serialVersionUID一致,
*如果一致就说明序列化类的版本与当前类版本是一样的,
可以反序列化成功,否则失败。
*/
继承Number的 Integer Long Short Byte
public方法 代码以Integer的相关方法代码举例
Integer 和 Long 都有方法Integer 和Long两个包装类方法一致 | xx对应的基本类型 Xx对应的包装类 |
文档建议:使用parseXxx ( String ) 一个字符串转换为 或者使用valueOf ( String ) 一个字符串转换为 | |
文档建议: valueOf( xxx )
| |
static int bitCount(xx i) | 返回该数值对应的二进制中 1 的个数 |
static int compareUnsigned(xx x, xx y) | 将参数x y看作无符号数并比较其大小 |
static Xx getXx(String nm) | 确定指定名称的系统属性的整数值。 |
static Xx getXx(String nm, xx val) | 确定指定名称的系统属性的整数值。 |
static Xx getXx(String nm, Xx val) | 确定指定名称的系统属性的整数值。 |
static xx highestOneBit(xx i) | 先将 i 除了前导0的剩下部分全置1 return i - (i >>> 1);//前导0_1_0..0 |
static xx lowestOneBit(xx i) | return i&-i; 返回二进制数最低位权值 1010:10 100100: 100 111: 1 |
static int numberOfLeadingZeros(xx i) | 返回前导0的个数 |
static int numberOfTrailingZeros(xx i) | 返回后导0的个数 |
static xx reverse(xx i) | 按位逆置 例:3210-2301-0123 相邻1位相互交换 相邻2位 相邻4位 0~ i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555; i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333; i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f; i = (i << 24) | ((i & 0xff00) << 8) |((i >>> 8) & 0xff00) | (i >>> 24);//0~7与24~31、8~15与16~23相互交换 |
static xx reverseBytes(xx i) | ((i >>> 24) ) | ((i >> 8) & 0xFF00) | ((i << 8) & 0xFF0000) | ((i << 24));//按字节交换4与1 2与3交换 |
static xx rotateLeft(xx i, int distance) | (i << distance) | (i >>> -distance) 循环左移 循环方向与 -distance的操作方向相同 |
static xx rotateRight(xx i, int distance) | (i >>> distance) | (i << -distance)循环右移 n为自然数 [-distance]后5+distance=32*n -distance实际移动看后5位 |
static int signum(xx i) | (i >> 31) | (-i >>> 31)返回符号位 |
static String toBinaryString(xx i) | xx ->String(xx的二进制形式) |
static String toOctalString(xx i) | xx ->String(xx的八进制形式) |
static String toString(int i, int radix) | xx ->String(xx的radix进制形式) |
static xx parseUnsignedXx (String s) | String->xx(十进制形式) |
static xx parseUnsignedXx (String s, int radix) | String->xx(radix进制形式) |
static Xx divideUnsigned(xx dividend, xx divisor) | (int)(toUnsignedLong(dividend) / toUnsignedLong(divisor))求商 |
static xx remainderUnsigned(xx dividend, xx divisor) | (int)(toUnsignedLong(dividend) %toUnsignedLong(divisor))求余数 |
Byte Short Integer Long Float Double
Byte | Short | Integer | Long | Float | Double | ||||||||
static int toUnsignedInt(xx x) | 0xff | 0xffff | × | × | × | × | ((int) x) & 0xffff Short中 | ||||||
static long toUnsignedLong(xx x) | 0xffL | 0xffffL | √ | × | × | × | ((long) x) & 0xffffL Short中 | ||||||
static xx sum(xx a, xx b) | × | × | √ | √ | √ | √ | 求和 | ||||||
static xx max(xx a, xx b) | × | × | √ | √ | √ | √ | 求两个数之中的最大值max | ||||||
static xx mix(xx a, xx b) | × | × | √ | √ | √ | √ | 求两个数之中的最小值min | ||||||
static String toHexString(xx i) | × | × | √ | √ | √ | √ | xx ->String(xx的十六进制形式) | ||||||
static xxx decode(String nm) | √ | √ | √ | √ | Byte Short 调用了Integer.decode(nm) 返回valueOf((xx)i) 在Integer Long 中均是自己实现的 1.解析前缀对应的进制2.调用xxx.valueOf(xx ,radix) | ||||||||
Double 和Float | |||||||||||||
xxx表double或float Xxx表Double或Float | Double 和Float 都有的方法 | ||||||||||||
java9已将此方法标记为已过时 |
文档建议: 使用 valueOf (xxx ) 例如 Float.valueOf( (float) value ) | ||||||||||||
java9已将此方法标记为已过时 |
文档建议:使用parseXxx(String) 将字符串转换为 或者使用valueOf (String ) 将一个字符串转换为Xxx对象 | ||||||||||||
static boolean isFinite(xxx f) | 如果参数是一个有限的浮点数,则返回 | 对于NaN和infinity返回false | |||||||||||
boolean isInfinite() | 如果参数是正无穷大或负无穷大此方法返回true | 否则返回false | |||||||||||
static boolean isInfinite(xxx v) | |||||||||||||
boolean isNaN() | 如果这个浮点值不是非数字(NAN)方法返回true | 否则返回false | |||||||||||
static boolean isNaN(xxx v) | |||||||||||||
Float独有的 | double独有的 | ||||||||||||
| |||||||||||||
static int floatToIntBits(float value) | static long doubleToLongBits(double value) | hashCode方法调用了该方法 | |||||||||||
static int floatToRawIntBits(float value) | static long doubleToRawLongBits(double value) | 返回浮点值的表示形式,并保留非数字(NaN)值。 | |||||||||||
Number继承类所共有的方法
| |||||||||||||
static int compare(xx x,xx y) | x>y 1 x==y 0 x<y -1 | 继承Number抽象类 | |||||||||||
byte byteValue() | 继承Number抽象类 | ||||||||||||
short shortValue() | 继承Number抽象类 | ||||||||||||
int intValue() | 继承Number抽象类 | ||||||||||||
long longValue() | 继承Number抽象类 | ||||||||||||
float floatValue() | 继承Number抽象类 | ||||||||||||
double doubleValue() | 继承Number抽象类 | ||||||||||||
int compareTo(Xx anotherXx) | |||||||||||||
Number继承类的构造函数均已被java9标记为已过时 | |||||||||||||
static Xx valueOf(xx b) | 8种包装类 √ | 基本类型->转换成包装类 用以代替构造函数Xx(xx value) | |||||||||||
static Xx valueOf(String s) | 字符串 (十进制)->转换成包装类 用以代替构造函数Xx(String s) | ||||||||||||
static Xx valueOf(String s, int radix) | Byte Short Integer Long √ | Float Double × | 字符串 ->转换成包装类 | ||||||||||
static xx parseXx(String s) | 8种包装类 √ | 字符串->基本类型(十进制) | |||||||||||
static xx parseXx(String s, int radix) | Byte Short Integer Long √ | Float Double × | 字符串->基本类型(radix进制) | ||||||||||
boolean equals(Object obj) | 继承Object | ||||||||||||
int hashCode() | 继承Object | ||||||||||||
static int hashCode(xx value) | |||||||||||||
String toString() | |||||||||||||
static String toString(xx f) | |||||||||||||
Integer
public final class Integer extends Number implements Comparable<Integer> {
//建议使用valueOf ,构造方法已被标记过时
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
public static Integer valueOf(String s) throws NumberFormatException {
return Integer.valueOf(parseInt(s, 10));
}
public static Integer valueOf(String s, int radix) throws NumberFormatException {
return Integer.valueOf(parseInt(s,radix));
}
parseInt()将字符串转成数字
1.字符串与数字的对应关系 string[0]->数字中的高位 string 0-length ->数字 高位-低位
2. 将结果存为负数 , 返回时再做正负变换(负数的边界的绝对值比正数的大一)
3. [-2147483648 , 2147483647] int范围
因此对于溢出判断 应有两个值作为标志位
即 limit 表 最大边界
multmin = limit/ radix ;// limit=-2147483647, radix =16 时,得到 multmin = -134217727 ;//0x7FFFFFF
//multmin的作用 以radix=10 limit=-2147483647 为例 判断字符串例如 String ="9147483647";
//对于limit来说 9147483647明显溢出 只能正确存储到 914748364 此时 multmin的作用就显现了
result < limit + digit
用于判断2147483649类似的值 limit(为负数)
与result - digit < limit 对比 在数学上是相等的 但考虑int存储范围 result < limit + digit是正确的
result - digit 的结果可能溢出,其结果不准确 ,故不正确
public static int parseInt(String s) throws NumberFormatException {
return parseInt(s,10);
}
public static int parseInt(String s, int radix)
throws NumberFormatException
{
if (s == null) {
throw new NumberFormatException("null");
}
if (radix < Character.MIN_RADIX) {
throw new NumberFormatException("radix " + radix +
" less than Character.MIN_RADIX");
}
if (radix > Character.MAX_RADIX) {
throw new NumberFormatException("radix " + radix +
" greater than Character.MAX_RADIX");
}
int result = 0;
boolean negative = false;
int i = 0, len = s.length();
int limit = -Integer.MAX_VALUE;
int multmin;
int digit;
if (len > 0) {
char firstChar = s.charAt(0);
if (firstChar < '0') { // Possible leading "+" or "-"
if (firstChar == '-') {
negative = true;
limit = Integer.MIN_VALUE;//当值为负数是,更换边界判断
} else if (firstChar != '+')
throw NumberFormatException.forInputString(s);
if (len == 1) // Cannot have lone "+" or "-"
throw NumberFormatException.forInputString(s);
i++;
}
multmin = limit / radix;
while (i < len) {
// Accumulating negatively avoids surprises near MAX_VALUE
digit = Character.digit(s.charAt(i++),radix);
if (digit < 0) {
throw NumberFormatException.forInputString(s);
}
if (result < multmin) { //multmin = -214748364
throw NumberFormatException.forInputString(s);
}
result *= radix;
if (result < limit + digit) {
throw NumberFormatException.forInputString(s);
}
result -= digit;
}
} else {
throw NumberFormatException.forInputString(s);
}
return negative ? result : -result;
}
bitCount (int)
返回该数值对应的二进制中 1 的个数
public static int bitCount(int i) {
//5 0101 设低四位i为 b3*2^3+b2*2^2+b1*2^1+b0
//(i >>> 1) & 0x55555555:b3*2^2+b1*2^1
i = i - ((i >>> 1) & 0x55555555);//等于(b3+b2)*2^2+(b1+b0)
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);//b3+b2+b1+b0
i = (i + (i >>> 4)) & 0x0f0f0f0f;//b7+b6+..+b1+b0
i = i + (i >>> 8);//b15+b14+..+b1+b0
i = i + (i >>> 16);//b31+b30+..+b1+b0
return i & 0x3f;// int 32位 10_0000 6位故与11_1111(0x3f)与
}
compare()与compareUnsigned()
//正常比较 x>y 返回1 x==y 返回0 x<y 返回 -1
public static int compare(int x, int y) {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
//负数>正数 -1>-2 2>1
public static int compareUnsigned(int x, int y) {
return compare(x + MIN_VALUE, y + MIN_VALUE);
}
decode()将字符串解码成Integer类型
支持带符号的十 八(前导0) 十六(0x 0X #)进制
public static Integer decode(String nm)
throws NumberFormatException
signum()返回符号位
public static int signum(int i) {
// HD, Section 2-7
//正 0 负:0 0 -1|1 0 0 = 1 0 -1
return (i >> 31) | (-i >>> 31);
}
divideUsigned(int int) 返回两个数视为无符号整数后进行除法的到的商
Character
java中字符由utf16为变长表示,长度可能是2或4个字节 java中的char是占用两个字节,只不过有些字符需要两个char来表示。
-
Character 的完整声明和构造方法
class Character implements java.io.Serializable, Comparable<Character>
{
//1.已过时的构造方法
public Character(char value) {
this.value = value;
}
//文档建议:使用valueOf(char)代替构造函数 通常是更好的选择,因为它可能产生明显更好的空间和时间性能。
public static Character valueOf(char c) {
if (c <= 127) { // must cache
return CharacterCache.cache[(int)c];
}
return new Character(c);
}
....
}
-
codepoint 和 char
1.关于UTF-16的编码的判断
代码点: int整型表示任一Unicode字符,整型编号称为代码点
BMP (Basic Multilingual Plane)字符 0x0000~0XFFFF 常用字符集 两字节表示
补增字符集 使用4字节表示 前两个字节 称为高代理项 0xD800~0XDFF HighSurrogate
后两个字节 称为低代理项 0XDC00~0XDFF LowSurrogate
- bmp 一个字符算作一个代码点 ,表示补增字符 两个字符 算作一个代码点
- 一个int型转换成UTF-16编码 可能是一个char型(BMP) 或者 两个char型(补增字符集)
关于UTF-16编码的判断的方法:
3个关于代码点类型的判断方法 isValidCodePoint()、isSupplementaryCodePoint()、isBmpCodePoint()
3个关于char的判断是否为代理项的方法isSurrogate()、isHighSurrogate、isLowSurrogate() (surrogate 表示代理点)
1个关于整型字符编码
isSupplementaryCodePoint(int codePoint) | 是否为补充代码点 | |
isValidCodePoint(int codePoint) | 是否为有效代码点 | U + 0000到U + 10FFFF |
isBmpCodePoint(int codePoint) | 是否为Bmp代码点 | codePoint>>>16 ==0 (小于0xFFFF) |
isHighSurrogate(char ch) | char是否为低代理项 | |
isLowSurrogate(char ch) | char是否为高代理项 | |
isSurrogate(char ch) | 是否为低/高代理项 | [0xD800 ,0xDfff] |
isSurrogatePair(char high, char low) | 是否high为高代理项 low为带代理项 调用HighSurrogate和isLowSurrogate` | |
public static int charCount(int codePoint) | 该代码点需要几个char表示 大于0x10000需2个 否则需1个 |
1.按codepoint代码点处理char[ ]
{BMP,char[intdex]->int ; 补增,char[index],char[index+1]->int}
-
codePointAt()
-
两种情况1.BMP 将一个char转成int返回 2.补增字符集 两个char 返回 tocodePoint()将高低代理项返回成int型代理点
//1和2 依靠codePointAtImpl实现其功能
public static int codePointAt(char[] a, int index);//1
public static int codePointAt(char[] a, int index, int limit) { //2
if (index >= limit || limit < 0 || limit > a.length) {
throw new IndexOutOfBoundsException();
}
return codePointAtImpl(a, index, limit);
public static int codePointAt(CharSequence seq, int index) { //3
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;
}
// codePointAtImpl() 访问修饰符default仅同一包中的类可访问
static int codePointAtImpl(char[] a, int index, int limit) {
char c1 = a[index];
/*index自增
*对于补增字符需要两个char表示,若c1为高代理项,则需要 a[index+1]是否是低代理项
*/ if (isHighSurrogate(c1) && ++index < limit) { //需判断是否越界
char c2 = a[index];
if (isLowSurrogate(c2)) {
return toCodePoint(c1, c2);
}
}
return c1;
}
-
codePointBefore() {BMP,char[intdex-1]->int ; 补增,char[index-2],char[index-1]->int}
public static int codePointBefore(char[] a, int index);
public static int codePointBefore(CharSequence seq, int index) ;
public static int codePointBefore(char[] a, int index, int start);
static int codePointBeforeImpl(char[] a, int index, int start) ;
在实现上与 codePointAt()等 不同在于第三个参数(codePointAt是边界,这个是开始点),遍历的方向 和遍历时的越界检查不同
-
toCodePoint() //Unicode根据高代理代码单元和低代理代码单元算出代码点
public static int toCodePoint(char high, char low) {
return ((high << 10) + low) + (MIN_SUPPLEMENTARY_CODE_POINT
- (MIN_HIGH_SURROGATE << 10)
- MIN_LOW_SURROGATE);
//MIN_HIGH_SURROGATE = 0xDC800;
//MIN_LOW_SURROGATE = 0xDC00;
//MIN_SUPPLEMENTARY_CODE_POINT = 0x10000;
}
- *确定给定的char值是否为Unicode高代理代码单元(也称为领先代理代码单元)。
- *这些值本身并不表示字符,而是用于UTF-16编码中的补充字符表示。
代码点X 与 高/低代理代码单元的关系
- // x-0x1000 将结果的10位高位 10位低位
- // 10位高位+D800 10位低位+Dc00 即是 高/低代理代码单元
(high-0xD800)<<10 + low-0xDC00 +0x10000 = 代码点 X
经变换就得到toCodePoint(char high, char low)方法中的表达式
代码点分成高低代理然后转换成字符
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); //索引小的 存高代理项
}
public static char highSurrogate(int codePoint) {
return (char) ((codePoint >>> 10) //逻辑右移
+ (MIN_HIGH_SURROGATE - (MIN_SUPPLEMENTARY_CODE_POINT >>> 10)));
}
public static char lowSurrogate(int codePoint) {
//codePoint & 0x3ff (1023 10个1) 结果保留低十位
return (char) ((codePoint & 0x3ff) + MIN_LOW_SURROGATE);
}
统计代码点个数 codePointCount()
- bmp 一个字符算作一个代码点 ,表示补增字符 两个字符 算作一个代码点
public static int codePointCount(CharSequence seq, int beginIndex, int endIndex) ;
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;
}
将codepoint转成char[ ] 返回的数组长度为 1 或 2
public static char[] toChars(int codePoint) {
if (isBmpCodePoint(codePoint)) { //BMP一个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();
}
}
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); //索引小的 存高代理项
}
public static int toChars(int codePoint, char[] dst, int dstIndex);
static void toSurrogates(int codePoint, char[] dst, int index);
offsetByCodePoints() 给定的index处偏移codePointOffset个代码点的索引
意义: 由于BMP一个字符表示 补增两个字符表示 ,造成的下标与字符单元不匹配的问题
public static int offsetByCodePoints(char[] a, int start, int count,
int index, int codePointOffset) ;
static int offsetByCodePointsImpl(char[]a, int start, int count,
int index, int codePointOffset) ;
public static int offsetByCodePoints(CharSequence seq, int index,
int codePointOffset) {
int length = seq.length();//(重载函数中)start + count扮演length
if (index < 0 || index > length) {
throw new IndexOutOfBoundsException();
}
int x = index;
if (codePointOffset >= 0) { //codePointOffset>=0 遍历方向为正向
int i;
// |codePointOffset|的值 为遍历次数,从index开始遍历
// i记录已完成的偏移数 x记录字符单元
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 { //codePointOffset<0 遍历方向为反向
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;
}
-
2.判断字符类型
public static int getType(char ch) | 返回一个指示字符的常规类别的值 基于 CharacterData (Character 的一个内部类)实现 |
public static int getType(int codePoint) |
public static int getType(char ch) {
return getType((int)ch);
}
public static int getType(int codePoint) {
return CharacterData.of(codePoint).getType(codePoint);
}
关于字符含义的判断 public static boolean类型的方法
大部分判断字符类型的方法其实现 基于getType的返回值或CharacterData.of(codePoint).方法名(codePoint)
有一些方法CharacterData.of(codePoint).同方法名(codePoint)
//调用CharacterData.of(codePoint)的同名函数
public static boolean isWhitespace(int codePoint) {
return CharacterData.of(codePoint).isWhitespace(codePoint);
//不同名函数
public static boolean isUpperCase(int codePoint) {
return getType(codePoint) == Character.UPPERCASE_LETTER ||
CharacterData.of(codePoint).isOtherUppercase(codePoint);
}
isDefined(char ch) | 字符是否在Unicode中已定义 |
isDefined(int codePoint) | |
isLowerCase(char ch) | 字符是否为小写字符 |
isLowerCase(int codePoint) | |
isUpperCase(char ch) | 字符是否为大写字符 |
isUpperCase(int codePoint) | |
isTitleCase(char ch) | 字符是否为标题字符 |
isTitleCase(int codePoint) | |
isDigit(char ch) | 字符是否为数字(包括中文全角数字) |
isDigit(int codePoint) | |
isLetter(char ch) | 是否为字母 UpperCase LowerCase TitleCase MODIFIER_LETTER OTHER_LETTER |
isLetter(int codePoint) | |
isAlphabetic(int codePoint) | 是否为字母(Alphabetic) 包括isLetter的范围+LETTER_NUMBER如罗马数字 "I II III IV V..." 基于 CharacterData (Character 的一个内部类)实现 |
isLetterOrDigit(char ch) | 是否为字母或数字 |
isLetterOrDigit(int codePoint) | |
isSpaceChar(int codePoint) | 是否Unicode空白字符 SPACE_SEPARATOR PARAGRAPH_SEPARATOR 仅能匹配空格字符本身 不能匹配实际效果产生空格的字符 如Tab '\t' |
isSpaceChar(char ch) | |
isWhitespace(char ch) | 确定指定字符依据 Java 标准是否为空白字符 可以匹配到'\t'等 基于 CharacterData (Character 的一个内部类)实现 |
isWhitespace(int codePoint) | |
isIdeographic(int codePoint) | 是否为象形文字 ,绝大数中文 返回true 基于 CharacterData (Character 的一个内部类)实现 |
isMirrored(char ch) | 是否为镜像字符 如: () [] {} <> 等; ' | 不是 基于 CharacterData (java.lang.CharacterData)实现 |
isMirrored(int codePoint) | |
isISOControl(char ch) | 确定指定字符是否为 ISO 8859-1编码中控制字符 单字节编码,向下兼容ASCII,其编码范围是0x00-0xFF,0x00-0x7F与ASCII一致,0x80-0x9F之间是控制字符,0xA0-0xFF之间是文字符号。是许多欧洲国家使用的编码标准 |
isISOControl(int codePoint) | |
isUnicodeIdentifierStart(char ch) | 是否允许将指定字符作为 Unicode 标识符中的首字符 基于 CharacterData (java.lang.CharacterData 抽象类)实现 返回true的条件 isLetter(ch) 返回true 或 getType(ch) 返回 LETTER_NUMBER. |
isUnicodeIdentifierStart(int codePoint) | |
isUnicodeIdentifierPart(char ch) | 是否可以是Unicode 标识符中首字符以外的部分 基于 CharacterData实现 |
isUnicodeIdentifierPart(int codePoint) |
3.关于java标识符(Identifier)或字符的一些判断
isJavaIdentifierStart(char ch) | 是否允许将指定字符作为 Java 标识符(Alphabetic $ _)中的首字符 基于 CharacterData (Character 的一个内部类)实现 |
isJavaIdentifierStart(int codePoint) | |
isJavaIdentifierPart(char ch) | 是否可以是 Java 标识符中首字符以外的部分。 JavaIdentifierStart + 数字 基于 CharacterData (和Character同级的抽象类)实现 |
isJavaIdentifierPart(int codePoint) | |
isIdentifierIgnorable(char ch) | 是否应该认为指定字符是 Java 标识符或 Unicode 标识符中可忽略的一个字符 基于 CharacterData (Character 的一个内部类)实现 |
isIdentifierIgnorable(int codePoint) |
-
3 转换
代理点与字符之间
public static int toCodePoint(char high, char low) | 代理对转换代码点 |
public static int toChars(int codePoint, char[] dst, int dstIndex) | 根据代码点返回字符 |
public static char[] toChars(int codePoint) | 将代码点转成字符数组 若为BMP则数组长度为1 |
static void toSurrogates(int codePoint, char[] dst, int index) | 代码点转成字符 索引小的高代理项 |
public static char highSurrogate(int codePoint) | 代码点返回高位代理 |
public static char lowSurrogate(int codePoint) | 代码点返回低位代理 |
字符与字符/整数之间的转换
public static char toLowerCase(char ch) | 将字符参数转换为小写 CharacterData 基于 CharacterData实现 |
public static int toLowerCase(int codePoint) | |
public static char toUpperCase(char ch) | 将字符参数转换为大写 CharacterData 基于 CharacterData )实现 |
public static int toUpperCase(int codePoint) | |
public static int toTitleCase(int codePoint) | 将字符参数转换为首字母大写 基于 CharacterData实现 |
public static char toTitleCase(char ch) | |
static int toUpperCaseEx(int codePoint) | 转换成大写后返回基于 CharacterData 实现 |
static char[] toUpperCaseCharArray(int codePoint) | 返回大写字符数组基于 CharacterData实现 |
public static String toString(char c) | 返回char参数的字符串表示形式 |
public final String toString() | String java.lang.Character.Subset.toString() return name |
将 字符或代码点 转换成 对应的数字 | (针对A-Z a-z '1' -'9') |
public static int getNumericValue(int codePoint) | 将'0'~'9'转换成0~9 对于字母a~z 无论大小写 10~35 基于 CharacterData 实现返回指定的 Unicode 字符示的int值 |
public static int getNumericValue(char ch) | |
public static int digit(char ch, int radix) | 返回使用指定基数(radix)的字符ch的数值 若字符无效返回-1 digit('G',16) 基于 CharacterData 实现 |
public static int digit(int codePoint, int radix) | |
public static char forDigit(int digit, int radix) | 与digit相反 将数字转换成给的进制的 字符 forDigit(15,16) 'F' 无效则返回'\0' |
public static byte getDirectionality(char ch) | 返回给定字符的 Unicode 方向属性。利用字符方向性来计算文本的视觉顺序 |
public static byte getDirectionality(int codePoint) |
public static String getName(int codePoint) | 返回字符指定名称 |
public static char reverseBytes(char ch) | 返回通过反转指定char值中的字节顺序而获得的值 |
public char charValue() | 返回value |
private static class CharacterCache | 将字符0-127放到缓存池中 |
public static Character valueOf(char c) | 字符小于128则从缓存池中取,否则New一个对象 |
public static int digit(char ch, int radix) {
return digit((int)ch, radix);
}
public static int digit(int codePoint, int radix) {
return CharacterData.of(codePoint).digit(codePoint, radix);
}