java笔记 Object 包装类

说明 若方法有多个重载,将会省略个别的代码具体实现过程,贴出该重载的声明.

---

目录

Object

toString() equals()  hashCode() clone() getClass()  finalize() notify() notifyAll()  wait()

包装类

      Character  

                  0.Character 的完整声明和构造方法

1. codepoint 和 char

         2.判断字符类型

3 转换

     Boolean 

                Boolean类的方法

 Number抽象类

继承Number的 Integer Long Short Byte

Integer 和 Long 的方法(Integer和Long两个包装类中的方法一致)

Double 和Float

Number继承类所共有的方法

         Integer部分方法详解

                  parseInt()将字符串转成数字 

bitCount (int)

compare()与compareUnsigned()

decode()将字符串解码成Integer类型　

signum()返回符号位

目录

目录

Object

包装类

Object

toString()

equals() 

hashCode()

clone()

getClass()

 finalize()

notify()

notifyAll() 

wait()

包装类

Boolean

 Boolean类的方法

Number抽象类

继承Number的 Integer Long Short Byte

Integer 和 Long 都有方法

Double 和Float

Number继承类所共有的方法

Integer

parseInt()将字符串转成数字 

bitCount (int)

compare()与compareUnsigned()

decode()将字符串解码成Integer类型　

signum()返回符号位

 Character  

Character 的完整声明和构造方法

 codepoint 和 char

1.按codepoint代码点处理char[ ] 

 代码点分成高低代理然后转换成字符

 

2.判断字符类型

3 转换

---

---

---

---

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 的一种情况

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	返回此Boolean对象的哈希码 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

ｐｕｂｌｉｃ方法　　　代码以Integer的相关方法代码举例

Integer 和 Long 都有方法 Integer 和Long两个包装类方法一致	xx对应的基本类型　Xx对应的包装类
Xx  ( String s )              java9已将此方法标记为已过时	以String为参数的构造函数   文档建议:使用parseXxx ( String ) 一个字符串转换为 long原始的 或者使用valueOf ( String )  一个字符串转换为Xxx对象
Integer ( int value )         java9已将此方法标记为已过时	构造函数 文档建议:  valueOf( xxx )
Long  ( long value )        java9已将此方法标记为已过时
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 |= (i >> 1); i |= (i >> 2);／／／／／ i |= (i >> 4); i |= (i >> 8);／／／／／ i |= (i >> 16); 先将　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 相邻１位相互交换　相邻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 都有的方法
Xxx (String s)  java9已将此方法标记为已过时	以String为参数的构造函数 文档建议: 使用 valueOf (xxx )  例如 Float.valueOf( (float) value )
Xxx(double value)  java9已将此方法标记为已过时	以double为参数的构造函数 文档建议:使用parseXxx(String) 将字符串转换为 xxx原始的 或者使用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(float value)已被标记为过时 以float为参数构造函数
static int   floatToIntBits(float value)	static long   doubleToLongBits(double value)						hashCode方法调用了该方法
static int   floatToRawIntBits(float value)	static long   doubleToRawLongBits(double value)						返回浮点值的表示形式，并保留非数字（NaN）值。
Number继承类所共有的方法 Byte Short Integer Long Float Double
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)							继承Ｏｂｊｅｃｔ
int    hashCode()							继承Ｏｂｊｅｃｔ
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 设低四位ｉ为　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 与 高/低代理代码单元的关系       

1.           // x-0x1000 将结果的10位高位 10位低位
2.           // 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);
    }